Updated README.md
Implemented serialize/deserialize for functions

- Serialize into and deserialize from strings is now possible.

- Added serdes unit tests

- Fixed bug that wasn't removing nil contributing monomials after
  certain operations.
Implemented additional metrics.

- Added a routine to count the total number of monomials.

- Added timings for XOR

- Started implementing ADDER
Added more static factory methods for functions

- Added support for double width AND and XOR functions.

- Added negation function.

- Added unit tests for double width AND and XOR, as well NEG.

- Moved some methods to FunctionUtils to cut down on code replication

- Resolves #12

- Resolves #13
Started implementation of more efficient AND

Started the implementation of homomorphic AND. Also refactored some
routines into FunctionUtils and implemented homomorphic binary
functions, which required a different treatment to handle the asymmetry
in inputs and outputs.
Optimized implementations classes for adder

This commit is a checkpoint commit for progress made in implementing a
functional adder, which has turned out to be a challenege as function
composition OOMs with only 8 GB. We tried alternate constructions
methods for homomorphic and are a trying a multistage compound function
version of AND, which leverages the underlying hardware's AND function
and doesn't require so many monomials to represent.

- Added utils for common homomorphic operations

- Implemented bitwise And, Not, Or, and Xor for use in compound
  functions.

- Added random invertible matrix static factory method to
  EnhancedBitMatrix.

- Added precondition failfast check to private key constructor.

- Implemented direct construction of homomorphic And, as opposed to
  construction via function composition.

- Added upper and lower identity static factory methods to
  PolynomialFunctionGF2

- Added unit tests for bitwise operations.
Fixed homomorphic AND unit test
Removed unnecessary spring and jetty dependencies
Fixed merge conflict
Added support for publishing to sonatype snapshot repo
Improved random function generation.

Random function generation logic was broken since it was limiting the
number of unique monomials in the generated function to the total number
of terms. I fixed this by generating each row at a time and keeping
track of monomials and relevant contributions in a map, allowing me to
use the fromMonomialContributionMap static factory method.

I also started moving moving static factory methods to the
PolynomialFunctions class that are not PolynomialFunctionGF2 specific
to make that class slightly less painful to reason about.

Also added a BitVector static factory method to generate bitvectors with
desired hamming weights and its corresponding unit tests.

Finally, I made the And unit tests switchable, but haven't finished
implementing efficient and.  I suspect the unit tests won't run with
less than 20G of RAM as a result.  The final resulting functions still
how about 5 ms for a homomorphic xor evaluation, which is only
marginally worse than the previous 3ms.

Java 8 should make things better with better vectorization.
Additionally, it should be fairly straightforward to parallelize
evaluation.
Improved random function generation.

Random function generation logic was broken since it was limiting the
number of unique monomials in the generated function to the total number
of terms. I fixed this by generating each row at a time and keeping
track of monomials and relevant contributions in a map, allowing me to
use the fromMonomialContributionMap static factory method.

I also started moving moving static factory methods to the
PolynomialFunctions class that are not PolynomialFunctionGF2 specific
to make that class slightly less painful to reason about.

Also added a BitVector static factory method to generate bitvectors with
desired hamming weights and its corresponding unit tests.

Finally, I made the And unit tests switchable, but haven't finished
implementing efficient and.  I suspect the unit tests won't run with
less than 20G of RAM as a result.  The final resulting functions still
how about 5 ms for a homomorphic xor evaluation, which is only
marginally worse than the previous 3ms.

Java 8 should make things better with better vectorization.
Additionally, it should be fairly straightforward to parallelize
evaluation.

Resolves #4.
Updated main to save public key to file
Merge branch 'develop' of https://github.com/kryptnostic/fhe-core into develop

* 'develop' of https://github.com/kryptnostic/fhe-core:
  Improved random function generation.
Use JUnit 4 assertions instead of JUnit 3.
Merge pull request #15 from asheldon/develop

Use JUnit 4 assertions instead of JUnit 3.
Partial implementation + comments for polynomial function helper methods
added todo indicator for polynomyialfunctions
changed semantic versioning logic to support snapshots and ivy/maven conventions. also added logic that prevents signing unless a flag (isReleaseVersion) is specified
change some syntax to support JDK6/android