Utils (homenc#351)

* create-context

* encrypt and decrypt

* example encode and decode scripts

* Added new serialize and deserialize functions

* Added utils tests that uses bats framework

* bug fixes

Co-Authored-By: Jack L Crawford <[email protected]>
Co-Authored-By: Enrico Steffinlongo <[email protected]>

Author: 3 people

.gitignore

@@ -1,6 +1,14 @@
 gh-pages/
 build/
 
+__pycache__/
+
+**.sk
+**.pk
+**.out
+**.ptxt
+**.ctxt
+
 src/fhe.a
 src/*.o
 src/*_x
@@ -12,8 +20,6 @@ src/*_x.dSYM
 src/*.sh
 src/*.bin
 src/*.txt
-src/misc/*.bin
-src/misc/*.txt
 
 **.bak
 **.swp

OLD_INSTALL.txt

@@ -117,7 +117,7 @@ library, currently these are:
                     flag should be passed to gcc
 
    -DHELIB_BOOT_THREADS  tells HElib to use a multithreading strategy for
-                         bootstrapping; requires -DHELIB_THREADS (see above) 
+                         bootstrapping; requires -DHELIB_THREADS (see above)
 
 
   -DDEBUG_PRINTOUT

include/helib/Context.h

@@ -412,6 +412,13 @@ class Context
     return ans;
   }
 
+  //! @brief Size in bits of Q.
+  long bitSizeOfQ() const
+  {
+    IndexSet primes = ctxtPrimes | specialPrimes;
+    return std::ceil(logOfProduct(primes) / log(2.0));
+  }
+
   //! @brief An estimate for the security-level
   double securityLevel() const
   {
@@ -427,6 +434,9 @@ class Context
     return (7.2 * phim / bitsize - 110);
   }
 
+  //! @brief print out algebra and other important info
+  void printout(std::ostream& out = std::cout) const;
+
   //! @brief Just add the given prime to the chain
   void AddSmallPrime(long q);
   void AddCtxtPrime(long q);

include/helib/NumbTh.h

@@ -608,6 +608,53 @@ class RandomState
 //! the char cc
 void seekPastChar(std::istream& str, int cc);
 
+/**
+ * @brief Advance the input stream `str` beyond white spaces and a single
+ * `separator` in the region-of-interest delimited by `begin_char` and
+ * `end_char`.
+ * @param str The stream to be advanced.
+ * @param begin_char The character determining the beginning of the
+ * region-of-interest (to advance beyond of).
+ * @param separator The separator character to advance beyond of.
+ * @param end_char The character determining the end of the region-of-interest
+ * (to advance beyond of).
+ * @return `true` if the region-of-interest is not completed (i.e.: `end_char`
+ * is not reached). `false` otherwise.
+ * @note Throws `helib::RuntimeError` if after spaces there is a character
+ * different from `begin_char`, `beyond`, or `end_char`.
+ */
+bool iterateInterestRegion(std::istream& str,
+                           int begin_char,
+                           int separator,
+                           int end_char);
+
+/**
+ * @brief Advance the input stream `istr` beyond white spaces.  Then split the
+ * region delimited by `begin_char` and `end_char` at each occurrence of
+ * `separator` that is not contained in an inner `begin_char` - `end_char`
+ * section.  The function returns a `std::vector<std::stringstream>` with the
+ * stream of every section of the input region.
+ * @param istr The stream to be advanced.
+ * @param begin_char The character determining the beginning of the
+ * region-of-interest.
+ * @param end_char The character determining the end of the
+ * region-of-interest
+ * @param separator The separator character to split at.
+ * @param skip_space Boolean value determining whether to skip spaces when
+ * extracting the sub-streams (default = `true`).
+ * @return A `std::vector<std::stringstream>` with the stream of every section
+ * of the input region.
+ * @throws IOError If the stream is badly formatted (i.e. it does not start with
+ * `begin_char` or it does not end with `end_char`).
+ * @note Requires `begin_char`, `end_char` and `separator` to be distinct and
+ * different from ` ` (space).
+ */
+std::vector<std::stringstream> extractTokenizeRegion(std::istream& istr,
+                                                     char begin_char,
+                                                     char end_char,
+                                                     char separator,
+                                                     bool skip_space = true);
+
 //! @brief Reverse a vector in place
 template <typename T>
 void reverse(NTL::Vec<T>& v, long lo, long hi)

include/helib/PAlgebra.h

@@ -153,8 +153,8 @@ class PAlgebra
   /* I/O methods */
 
   //! Prints the structure in a readable form
-  void printout() const;
-  void printAll() const; // print even more
+  void printout(std::ostream& out = std::cout) const;
+  void printAll(std::ostream& out = std::cout) const; // print even more
 
   /* Access methods */
 

include/helib/PolyMod.h

@@ -188,9 +188,10 @@ class PolyMod
   NTL::ZZX getG() const;
 
   /**
-   * @brief Getter function that returns the data of `PolyMod` as an `NTL::ZZX`.
+   * @brief Getter function that returns the data of `PolyMod` as an
+   * `NTL::ZZX` const reference.
    **/
-  NTL::ZZX getData() const;
+  const NTL::ZZX& getData() const;
 
   /**
    * @brief Equals operator between two `PolyMod` objects.
@@ -373,6 +374,46 @@ class PolyMod
    **/
   PolyMod& operator-=(const NTL::ZZX& otherPoly);
 
+  /**
+   * @brief Deserialize a `PolyMod` object from the input stream `is`.
+   * @param is Input `std::istream`.
+   * @param poly Destination `PolyMod` object.
+   * @throws IOError if the stream is badly formatted (i.e. it is not delimited
+   * by '[' and ']').
+   * @note `poly` must be constructed with an appropriate p2r and G @b BEFORE
+   * calling this function. For example,
+   * @code
+   * PolyMod my_poly(p2r, G);
+   * deserialize(std::cin, my_poly);
+   * @endcode
+   *
+   * The input stream has to be formatted as a comma-separated list surrounded
+   * by '[' and ']'.\n
+   * Each element of the list will be deserialized as a coefficient of the
+   * polynomial.\n
+   * For example '['coef0', 'coef1', 'coef2']' will be deserialized as a
+   * `PolyMod` object `poly` where `poly[0]=coef0`, `poly[1]=coef1`,
+   * `poly[2]=coef2` and `poly[i]=0` for `i>2`.
+   **/
+  friend void deserialize(std::istream& is, PolyMod& poly);
+
+  /**
+   * @brief Serialize a `PolyMod` to the output stream `os`.
+   * @param os Output `std::ostream`.
+   * @param poly `PolyMod` object to be written.
+   * @return Input `std::ostream` post writing.
+   * @note p2r and G are not serialized, see note of `deserialize`.
+   *
+   * The output stream will be formatted as a comma-separated list surrounded by
+   * '[' and ']'.\n
+   * Each coefficient of `poly` will be serialized in an element of such list by
+   * the `>>` operator.\n
+   * For example if we have a `PolyMod` object `poly` such that `poly[0]=coef0`,
+   * `poly[1]=coef1`, `poly[2]=coef2`, and `poly[i]=0` for `i>2`, it will be
+   * serialized as '['coef0', 'coef1', 'coef2']'.
+   **/
+  friend void serialize(std::ostream& os, const PolyMod& slot);
+
   /**
    * @brief Input shift operator.
    * @param is Input `std::istream`.
@@ -384,6 +425,16 @@ class PolyMod
    * PolyMod my_poly(p2r, G);
    * std::cin >> my_poly;
    * @endcode
+   *
+   * The input stream has to be formatted as a comma-separated list surrounded
+   * by '[' and ']'.\n
+   * Each element of the list will be deserialized as a coefficient of the
+   * polynomial.\n
+   * If the number of tokens in the list is less than the number of
+   * coefficients, the higher-degree coefficients will be padded by 0.\n
+   * For example '['coef0', 'coef1', 'coef2']' will be deserialized as a
+   * `PolyMod` object `poly` where `poly[0]=coef0`, `poly[1]=coef1`,
+   * `poly[2]=coef2` and `poly[i]=0` for `i>2`.
    **/
   friend std::istream& operator>>(std::istream& is, PolyMod& poly);
 
@@ -392,7 +443,15 @@ class PolyMod
    * @param os Output `std::ostream`.
    * @param poly `PolyMod` object to be written.
    * @return Input `std::ostream` post writing.
-   * @note p2r and G are not serialised, see note of `operator>>`.
+   * @note p2r and G are not serialized, see note of `operator>>`.
+   *
+   * The output stream will be formatted as a comma-separated list surrounded by
+   * '[' and ']'.\n
+   * Each coefficient of `poly` will be serialized in an element of such list by
+   * the `>>` operator.\n
+   * For example if we have a `PolyMod` object `poly` such that `poly[0]=coef0`,
+   * `poly[1]=coef1`, `poly[2]=coef2`, and `poly[i]=0` for `i>2`, it will be
+   * serialized as '['coef0', 'coef1', 'coef2']'.
    **/
   friend std::ostream& operator<<(std::ostream& os, const PolyMod& poly);