helib Namespace Reference
Namespaces | |
| FHEglobals | |
Classes | |
| class | add_pa_impl |
| class | AddDAG |
| A class representing the logic of the order of bit products when adding two integers. More... | |
| class | And |
An object representing the logical AND expression which inherits from Expr. More... | |
| class | applyPerm_pa_impl |
| class | ArgMap |
| Basic class for arg parsing. Example use: More... | |
| class | BasicAutomorphPrecon |
| Pre-computation to speed many automorphism on the same ciphertext. More... | |
| struct | BGV |
| Type for BGV scheme, to be used as template parameter. More... | |
| class | BipartitleGraph |
| A bipartite flow graph. More... | |
| class | BlockMatMul1D |
| class | BlockMatMul1D_derived |
| struct | BlockMatMul1D_derived_impl |
| class | BlockMatMul1D_partial |
| class | BlockMatMul1DExec |
| struct | BlockMatMul1DExec_construct |
| class | BlockMatMulFull |
| class | BlockMatMulFull_derived |
| class | BlockMatMulFullExec |
| struct | BlockMatMulFullExec_construct |
| class | BlockMatMulFullHelper |
| struct | CKKS |
| Type for CKKS scheme, to be used as template parameter. More... | |
| class | Cmodulus |
| Provides FFT and iFFT routines modulo a single-precision prime. More... | |
| class | ColNumber |
An object representing a column of a database as an expression which inherits from Expr. More... | |
| class | ColPerm |
| Permuting a single dimension (column) of a hypercube. More... | |
| class | ConstCubeSlice |
| A constant lower-dimension slice of a hypercube. More... | |
| struct | ConstMultiplier |
| struct | ConstMultiplier_DoubleCRT |
| struct | ConstMultiplier_DoubleCRT_CKKS |
| struct | ConstMultiplier_zzX |
| struct | ConstMultiplier_zzX_CKKS |
| struct | ConstMultiplierCache |
| class | Context |
| Maintaining the parameters. More... | |
| class | Ctxt |
| A Ctxt object holds a single ciphertext. More... | |
| class | CtxtPart |
| One entry in a ciphertext std::vector. More... | |
| class | CubeSignature |
| Holds a vector of dimensions for a hypercube and some additional data. More... | |
| class | CubeSlice |
| A lower-dimension slice of a hypercube. More... | |
| class | DAGnode |
| A node in an addition-DAG structure. More... | |
| class | Database |
An object representing a database which is a HElib::Matrix<TXT>. More... | |
| class | decode_pa_impl |
| class | deep_clone |
| Deep copy: initialize with clone. More... | |
| class | DoubleCRT |
| Implementing polynomials (elements in the ring R_Q) in double-CRT form. More... | |
| class | DoubleCRTHelper |
| A helper class to enforce consistency within an DoubleCRTHelper object. More... | |
| class | DynamicCtxtPowers |
| Store powers of X, compute them dynamically as needed. More... | |
| class | encode_pa_impl |
| class | EncryptedArray |
| A simple wrapper for a smart pointer to an EncryptedArrayBase. This is the interface that higher-level code should use. More... | |
| class | EncryptedArrayBase |
| virtual class for data-movement operations on arrays of slots More... | |
| class | EncryptedArrayCx |
| A different derived class to be used for the approximate-numbers scheme. More... | |
| class | EncryptedArrayDerived |
| Derived concrete implementation of EncryptedArrayBase. More... | |
| class | equals_pa_impl |
| class | EvalMap |
| Class that provides the functionality for the linear transforms used in boostrapping. The constructor is invoked with three arguments: More... | |
| class | Exception |
| Base class that other HElib exception classes inherit from. More... | |
| class | ExplicitReplicator |
| An implementation of ReplicateHandler that explicitly returns all the replicated ciphertexts in one big vector. More... | |
| struct | Expr |
| Base structure for logical expressions. More... | |
| struct | fhe_stats_record |
| class | FHEtimer |
| A simple class to accumulate time. More... | |
| class | FlowEdge |
| An edge in a flow graph. More... | |
| class | frobeniusAutomorph_pa_impl |
| class | FullBinaryTree |
| A simple implementation of full binary trees (each non-leaf has 2 children) More... | |
| class | GenDescriptor |
| A minimal description of a generator for the purpose of building tree. More... | |
| class | general_range |
| class | GeneralAutomorphPrecon |
| class | GeneralAutomorphPrecon_BSGS |
| class | GeneralAutomorphPrecon_FULL |
| class | GeneralAutomorphPrecon_UNKNOWN |
| class | GeneralBenesNetwork |
| Implementation of generalized Benes Permutation Network. More... | |
| class | GeneratorTrees |
| A std::vector of generator trees, one per generator in Zm*/(p) More... | |
| struct | half_FFT |
| class | HyperCube |
| A multi-dimensional cube. More... | |
| class | IndexMap |
| IndexMap<T> implements a generic map indexed by a dynamic index set. More... | |
| class | IndexMapInit |
| Initializing elements in an IndexMap. More... | |
| class | IndexSet |
| A dynamic set of non-negative integers. More... | |
| class | InvalidArgument |
| Inherits from Exception and std::invalid_argument. More... | |
| class | IOError |
| Inherits from Exception and std::runtime_error. More... | |
| class | KeySwitch |
| Key-switching matrices. More... | |
| class | LabeledEdge |
| A generic directed edge in a graph with some labels. More... | |
| class | LabeledVertex |
| A generic node in a graph with some labels. More... | |
| class | Logger |
| Logger class that handles warning printouts. More... | |
| class | LogicError |
| Inherits from Exception and std::logic_error. More... | |
| class | MappingData |
| Auxiliary structure to support encoding/decoding slots. More... | |
| class | MatMul1D |
| class | MatMul1D_CKKS |
| class | MatMul1D_derived |
| struct | MatMul1D_derived_impl |
| class | MatMul1D_partial |
| class | MatMul1DExec |
| struct | MatMul1DExec_construct |
| class | MatMulExecBase |
| class | MatMulFull |
| class | MatMulFull_derived |
| class | MatMulFullExec |
| struct | MatMulFullExec_construct |
| class | MatMulFullHelper |
| class | MatrixView |
| class | ModuliSizes |
| A helper class to map required modulo-sizes to primeSets. More... | |
| struct | mul_BlockMatMul1D_impl |
| struct | mul_BlockMatMulFull_impl |
| struct | mul_MatMul1D_impl |
| struct | mul_MatMulFull_impl |
| class | mul_pa_impl |
| class | negate_pa_impl |
| class | Or |
An object representing the logical OR expression which inherits from Expr. More... | |
| class | OutOfRangeError |
| Inherits from Exception and std::out_of_range. More... | |
| class | PAlgebra |
| The structure of (Z/mZ)* /(p) More... | |
| class | PAlgebraMod |
| The structure of Z[X]/(Phi_m(X), p) More... | |
| class | PAlgebraModBase |
| Virtual base class for PAlgebraMod. More... | |
| class | PAlgebraModCx |
| class | PAlgebraModDerived |
| A concrete instantiation of the virtual class. More... | |
| class | PermNetLayer |
| The information needed to apply one layer of a permutation network. More... | |
| class | PermNetwork |
| A full permutation network. More... | |
| class | PGFFT |
| class | PlaintextArray |
| class | PlaintextArrayBase |
| class | PlaintextArrayDerived |
| class | PolyMod |
An object that contains an NTL::ZZX polynomial along with a coefficient modulus p2r and a polynomial modulus G. More... | |
| struct | PolyModRing |
| Lightweight type for describing the structure of a single slot of the plaintext space. More... | |
| class | PowerfulConversion |
| Conversion between powerful representation in R_m/(q) and zz_pX. More... | |
| class | PowerfulDCRT |
| Conversion between powerful representation, DoubleCRT, and ZZX. More... | |
| class | PowerfulTranslationIndexes |
| Holds index tables for translation between powerful and zz_pX. More... | |
| struct | PrimeGenerator |
| class | print_pa_impl |
| struct | PtrMatrix |
| An abstract class for an array of PtrVectors. More... | |
| struct | PtrMatrix_PtPtrVector |
| An implementation of PtrMatrix using vector< PtrVector<T>* > More... | |
| struct | PtrMatrix_ptVec |
| An implementation of PtrMatrix using Vec< Vec<T>* > More... | |
| struct | PtrMatrix_ptvector |
| An implementation of PtrMatrix using vector< vector<T>* > More... | |
| struct | PtrMatrix_Vec |
| An implementation of PtrMatrix using Vec< Vec<T> > More... | |
| struct | PtrMatrix_vector |
| An implementation of PtrMatrix using vector< vector<T> > More... | |
| struct | PtrVector |
| Abstract class for an array of objects. More... | |
| struct | PtrVector_Singleton |
| An implementation of PtrVector from a single T object. More... | |
| struct | PtrVector_slice |
| An implementation of PtrVector as a slice of another PtrVector. More... | |
| struct | PtrVector_VecPt |
| An implementation of PtrVector using Vec<T*> More... | |
| struct | PtrVector_VecT |
| An implementation of PtrVector using Vec<T> More... | |
| struct | PtrVector_vectorPt |
| An implementation of PtrVector using vector<T*> More... | |
| struct | PtrVector_vectorT |
| An implementation of PtrVector using vector<T> More... | |
| class | Ptxt |
An object that mimics the functionality of the Ctxt object, and acts as a convenient entry point for inputting/encoding data which is to be encrypted. More... | |
| class | PubKey |
| The public key. More... | |
| struct | PubKeyHack |
| struct | quarter_FFT |
| struct | Query_t |
| Structure containing all information required for an HE query. More... | |
| class | QueryBuilder |
An object used to construct a Query_t object from a logical expression. More... | |
| class | random_pa_impl |
| class | RandomBlockMatrix |
| class | RandomFullBlockMatrix |
| class | RandomFullMatrix |
| class | RandomMatrix |
| class | RandomMultiBlockMatrix |
| class | RandomMultiMatrix |
| class | RandomState |
| Facility for "restoring" the NTL PRG state. More... | |
| class | RecryptData |
| A structure to hold recryption-related data inside the Context. More... | |
| class | replicate_pa_impl |
| class | ReplicateHandler |
| An abstract class to handle call-backs to get the output of replicate. More... | |
| class | rotate_pa_impl |
| class | RuntimeError |
| Inherits from Exception and std::runtime_error. More... | |
| class | ScratchCell |
| A class to help manage the allocation of temporary Ctxt objects. More... | |
| class | SecKey |
| The secret key. More... | |
| class | shallow_clone |
| Shallow copy: initialize with copy constructor. More... | |
| class | shift_pa_impl |
| class | SKHandle |
| A handle, describing the secret-key element that "matches" a part, of the form s^r(X^t). More... | |
| class | sub_pa_impl |
| class | SubDimension |
| A node in a tree relative to some generator. More... | |
| class | SumRegister |
| Class to do a binary tree summation as results appear to keep memory usage to a minimum. More... | |
| class | Tensor |
| struct | TensorSlice |
| class | ThinEvalMap |
| Class that provides the functionality for the linear transforms used in "thin" boostrapping, where slots are assumed to contain constants. The interface is exactly the same as for EvalMap, except that the constructor does not have a normal_basis parameter. More... | |
| class | ThinRecryptData |
| Same as above, but for "thin" bootstrapping, where the slots are assumed to contain constants. More... | |
| class | TreeNode |
| A node in a full binary tree. More... | |
| class | version |
| The class acts as a namespace with all members static. Holds the version number for this code of HElib. More... | |
| class | zz_pXModulus1 |
| Auxiliary classes to facilitate faster reduction mod Phi_m(X) when the input has degree less than m. More... | |
| class | ZZ_pXModulus1 |
| placeholder for pXModulus ...no optimizations More... | |
Typedefs | |
| typedef PtrVector< Ctxt > | CtPtrs |
| typedef PtrVector_VecT< Ctxt > | CtPtrs_VecCt |
| typedef PtrVector_vectorT< Ctxt > | CtPtrs_vectorCt |
| typedef PtrVector_VecPt< Ctxt > | CtPtrs_VecPt |
| typedef PtrVector_vectorPt< Ctxt > | CtPtrs_vectorPt |
| typedef PtrVector_slice< Ctxt > | CtPtrs_slice |
| typedef PtrMatrix< Ctxt > | CtPtrMat |
| typedef PtrMatrix_Vec< Ctxt > | CtPtrMat_VecCt |
| typedef PtrMatrix_vector< Ctxt > | CtPtrMat_vectorCt |
| typedef PtrMatrix_ptVec< Ctxt > | CtPtrMat_ptVecCt |
| typedef PtrMatrix_ptvector< Ctxt > | CtPtrMat_ptvectorCt |
| typedef std::shared_ptr< DoubleCRT > | DCRTptr |
| typedef std::shared_ptr< NTL::ZZX > | ZZXptr |
| typedef std::complex< double > | cx_double |
| typedef std::unordered_map< long, FlowEdge > | FNeighborList |
| typedef std::vector< FNeighborList > | FlowGraph |
| typedef std::unordered_multimap< long, LabeledEdge > | LNeighborList |
| template<typename T > | |
| using | Vector = Tensor< T, 1 > |
| template<typename T > | |
| using | Matrix = Tensor< T, 2 > |
| typedef long | LONG |
| using | QueryExpr = std::shared_ptr< Expr > |
An alias for a shared pointer to an Expr object. More... | |
| typedef NTL::Vec< long > | Permut |
| A simple permutation is just a vector with p[i]=\pi_i. More... | |
| typedef FullBinaryTree< SubDimension > | OneGeneratorTree |
| typedef NTL::Vec< long > | zzX |
| typedef std::pair< long, long > | NodeIdx |
| template<class T > | |
| using | aligned_vector = PGFFT::aligned_vector< T > |
| typedef complex< double > | cmplx_t |
| typedef long double | ldbl |
Enumerations | |
| enum | PA_tag { PA_GF2_tag, PA_zz_p_tag, PA_cx_tag } |
Functions | |
| template<typename ExceptionTy = ::helib::LogicError, typename T = void> | |
| void | assertTrue (const T &value, const std::string &message) |
| template<typename ExceptionTy = ::helib::LogicError, typename T = void> | |
| void | assertFalse (T value, const std::string &message) |
| template<typename ExceptionTy = ::helib::LogicError, typename T = void> | |
| void | assertEq (const T &a, const T &b, const std::string &message) |
| template<typename ExceptionTy = ::helib::LogicError, typename T = void> | |
| void | assertNeq (const T &a, const T &b, const std::string &message) |
| template<typename ExceptionTy = ::helib::LogicError, typename T = void> | |
| void | assertNotNull (const T &p, const std::string &message) |
| template<typename ExceptionTy = ::helib::OutOfRangeError, typename T = void> | |
| void | assertInRange (const T &elem, const T &min, const T &max, const std::string &message, bool right_inclusive=false) |
| std::vector< long > | longToBitVector (long num, long bitSize) |
| Returns a number as a vector of bits with LSB on the left. More... | |
| void | binaryCond (CtPtrs &output, const Ctxt &cond, const CtPtrs &trueValue, const CtPtrs &falseValue) |
Implementation of output = cond * trueValue + (1 - cond) * falseValue. More... | |
| void | binaryMask (CtPtrs &binaryNums, const Ctxt &mask) |
Zeroes the slots of binaryNums where the corresponding slot of mask is 0. More... | |
| void | concatBinaryNums (CtPtrs &output, const CtPtrs &a, const CtPtrs &b) |
Concatenates two binary numbers into a single CtPtrs object. E.g. If a=10111, b=00101 then output = 1011100101. More... | |
| void | splitBinaryNums (CtPtrs &leftSplit, CtPtrs &rightSplit, const CtPtrs &input) |
Splits a single binary number into two binary numbers leftSplit and rightSplit. More... | |
| void | leftBitwiseShift (CtPtrs &output, const CtPtrs &input, const long shamt) |
Left shift input by shamt. More... | |
| void | bitwiseRotate (CtPtrs &output, const CtPtrs &input, long rotamt) |
Rotate input by rotamt. More... | |
| void | bitwiseXOR (CtPtrs &output, const CtPtrs &lhs, const CtPtrs &rhs) |
Compute a bitwise XOR between lhs and rhs. More... | |
| void | bitwiseOr (CtPtrs &output, const CtPtrs &lhs, const CtPtrs &rhs) |
Compute a bitwise OR between lhs and rhs. More... | |
| void | bitwiseAnd (CtPtrs &output, const CtPtrs &lhs, const CtPtrs &rhs) |
Compute a bitwise AND between lhs and rhs. More... | |
| void | bitwiseAnd (CtPtrs &output, const CtPtrs &input, const std::vector< long > mask) |
Compute a bitwise AND between input and a std::vector<long>. More... | |
| void | bitwiseNot (CtPtrs &output, const CtPtrs &input) |
Compute a bitwise NOT of input. More... | |
| void | addTwoNumbers (CtPtrs &sum, const CtPtrs &lhs, const CtPtrs &rhs, long sizeLimit=0, std::vector< zzX > *unpackSlotEncoding=nullptr) |
| Adds two numbers in binary representation where each ciphertext of the input vector contains a bit. More... | |
| void | negateBinary (CtPtrs &negation, const CtPtrs &input) |
| Negates a number in binary 2's complement representation. More... | |
| void | subtractBinary (CtPtrs &difference, const CtPtrs &lhs, const CtPtrs &rhs, std::vector< zzX > *unpackSlotEncoding=nullptr) |
Subtracts rhs from lhs where lhs, rhs are in 2's complement. More... | |
| long | fifteenOrLess4Four (const CtPtrs &out, const CtPtrs &in, long sizeLimit=4) |
| Add together up to fifteen {0,1} integers, producing a 4-bit counter. More... | |
| void | addManyNumbers (CtPtrs &sum, CtPtrMat &numbers, long sizeLimit=0, std::vector< zzX > *unpackSlotEncoding=nullptr) |
| Sum an arbitrary amount of numbers in binary representation. More... | |
| void | multTwoNumbers (CtPtrs &product, const CtPtrs &lhs, const CtPtrs &rhs, bool rhsTwosComplement=false, long sizeLimit=0, std::vector< zzX > *unpackSlotEncoding=nullptr) |
| Multiply two numbers in binary representation where each ciphertext of the input vector contains a bit. More... | |
| void | decryptBinaryNums (std::vector< long > &pNums, const CtPtrs &eNums, const SecKey &sKey, const EncryptedArray &ea, bool twosComplement=false, bool allSlots=true) |
| Decrypt the binary numbers that are encrypted in eNums. More... | |
| void | packedRecrypt (const CtPtrs &a, const CtPtrs &b, std::vector< zzX > *unpackSlotEncoding) |
| Function for packed recryption to recrypt multiple numbers. More... | |
| void | compareTwoNumbers (CtPtrs &max, CtPtrs &min, Ctxt &mu, Ctxt &ni, const CtPtrs &a, const CtPtrs &b, bool twosComplement=false, std::vector< zzX > *unpackSlotEncoding=nullptr) |
Compares two integers in binary a, b. Returns max(a, b), min(a, b) and indicator bits mu=(a>b) and ni=(a<b) More... | |
| void | compareTwoNumbers (Ctxt &mu, Ctxt &ni, const CtPtrs &a, const CtPtrs &b, bool twosComplement=false, std::vector< zzX > *unpackSlotEncoding=nullptr) |
Compares two integers in binary a, b. Returns only indicator bits mu=(a>b) and ni=(a<b). More... | |
| int | readEyeCatcher (std::istream &str, const char *expect) |
| void | writeEyeCatcher (std::ostream &str, const char *eye) |
| void | write_ntl_vec_long (std::ostream &str, const NTL::vec_long &vl, long intSize=BINIO_64BIT) |
| void | read_ntl_vec_long (std::istream &str, NTL::vec_long &vl) |
| long | read_raw_int (std::istream &str) |
| int | read_raw_int32 (std::istream &str) |
| void | write_raw_int (std::ostream &str, long num) |
| void | write_raw_int32 (std::ostream &str, int num) |
| void | write_raw_double (std::ostream &str, const double d) |
| double | read_raw_double (std::istream &str) |
| void | write_raw_xdouble (std::ostream &str, const NTL::xdouble xd) |
| NTL::xdouble | read_raw_xdouble (std::istream &str) |
| void | write_raw_ZZ (std::ostream &str, const NTL::ZZ &zz) |
| void | read_raw_ZZ (std::istream &str, NTL::ZZ &zz) |
| template<typename T > | |
| void | write_raw_vector (std::ostream &str, const std::vector< T > &v) |
| template<> | |
| void | write_raw_vector< long > (std::ostream &str, const std::vector< long > &v) |
| template<> | |
| void | write_raw_vector< double > (std::ostream &str, const std::vector< double > &v) |
| template<typename T > | |
| void | read_raw_vector (std::istream &str, std::vector< T > &v, T &init) |
| template<typename T > | |
| void | read_raw_vector (std::istream &str, std::vector< T > &v) |
| template<> | |
| void | read_raw_vector< long > (std::istream &str, std::vector< long > &v) |
| template<> | |
| void | read_raw_vector< double > (std::istream &str, std::vector< double > &v) |
| template<typename T > | |
| void | read_raw_vector (std::istream &str, std::vector< T > &v, const Context &context) |
| void | BluesteinInit (long n, const NTL::zz_p &root, NTL::zz_pX &powers, NTL::Vec< NTL::mulmod_precon_t > &powers_aux, NTL::fftRep &Rb) |
| initialize bluestein More... | |
| void | BluesteinFFT (NTL::zz_pX &x, long n, const NTL::zz_p &root, const NTL::zz_pX &powers, const NTL::Vec< NTL::mulmod_precon_t > &powers_aux, const NTL::fftRep &Rb) |
| apply bluestein More... | |
| template<typename X , typename Cloner > | |
| void | swap (cloned_ptr< X, Cloner > &x, cloned_ptr< X, Cloner > &y) |
| template<typename X , typename Cloner > | |
| void | swap (copied_ptr< X, Cloner > &x, copied_ptr< X, Cloner > &y) |
| double | lweEstimateSecurity (int n, double log2AlphaInv, int hwt) |
| An estimate for the security-level. This has a lower bound of 0. More... | |
| long | FindM (long k, long nBits, long c, long p, long d, long s, long chosen_m, bool verbose=false) |
| Returns smallest parameter m satisfying various constraints: More... | |
| void | writeContextBase (std::ostream &s, const Context &context) |
| write [m p r gens ords] data More... | |
| void | readContextBase (std::istream &s, unsigned long &m, unsigned long &p, unsigned long &r, std::vector< long > &gens, std::vector< long > &ords) |
| read [m p r gens ords] data, needed to construct context More... | |
| std::unique_ptr< Context > | buildContextFromAscii (std::istream &str) |
| void | writeContextBaseBinary (std::ostream &str, const Context &context) |
| write [m p r gens ords] data More... | |
| void | writeContextBinary (std::ostream &str, const Context &context) |
| void | readContextBaseBinary (std::istream &s, unsigned long &m, unsigned long &p, unsigned long &r, std::vector< long > &gens, std::vector< long > &ords) |
| read [m p r gens ords] data, needed to construct context More... | |
| std::unique_ptr< Context > | buildContextFromBinary (std::istream &str) |
| void | readContextBinary (std::istream &str, Context &context) |
| void | buildModChain (Context &context, long nBits, long nDgts=3, bool willBeBootstrappable=false, long skHwt=0, long resolution=3, long bitsInSpecialPrimes=0) |
| void | endBuildModChain (Context &context) |
| void | packedRecrypt (const CtPtrs &cPtrs, const std::vector< zzX > &unpackConsts, const EncryptedArray &ea) |
| void | packedRecrypt (const CtPtrs &array, const std::vector< zzX > &unpackConsts, const EncryptedArray &ea, long belowLvl) |
| void | packedRecrypt (const CtPtrMat &m, const std::vector< zzX > &unpackConsts, const EncryptedArray &ea, long belowLvl=LONG_MAX) |
| long | findMinBitCapacity (const CtPtrs &v) |
| long | findMinBitCapacity (const CtPtrMat &m) |
| long | findMinBitCapacity (std::initializer_list< const CtPtrs * > list) |
| void | innerProduct (Ctxt &result, const CtPtrs &v1, const CtPtrs &v2) |
| Ctxt | innerProduct (const CtPtrs &v1, const CtPtrs &v2) |
| std::ostream & | operator<< (std::ostream &s, const SKHandle &handle) |
| std::istream & | operator>> (std::istream &s, CtxtPart &p) |
| std::ostream & | operator<< (std::ostream &s, const CtxtPart &p) |
| void | totalProduct (Ctxt &out, const std::vector< Ctxt > &v) |
| void | incrementalProduct (std::vector< Ctxt > &v) |
| void | innerProduct (Ctxt &result, const std::vector< Ctxt > &v1, const std::vector< Ctxt > &v2) |
| Ctxt | innerProduct (const std::vector< Ctxt > &v1, const std::vector< Ctxt > &v2) |
| void | innerProduct (Ctxt &result, const std::vector< Ctxt > &v1, const std::vector< DoubleCRT > &v2) |
| Compute the inner product of a vectors of ciphertexts and a constant vector. More... | |
| Ctxt | innerProduct (const std::vector< Ctxt > &v1, const std::vector< DoubleCRT > &v2) |
| void | innerProduct (Ctxt &result, const std::vector< Ctxt > &v1, const std::vector< NTL::ZZX > &v2) |
| Ctxt | innerProduct (const std::vector< Ctxt > &v1, const std::vector< NTL::ZZX > &v2) |
| void | CheckCtxt (const Ctxt &c, const char *label) |
| print to cerr some info about ciphertext More... | |
| void | extractDigits (std::vector< Ctxt > &digits, const Ctxt &c, long r=0) |
| Extract the mod-p digits of a mod-p^r ciphertext. More... | |
| void | extractDigits (std::vector< Ctxt > &digits, const Ctxt &c, long r, bool shortCut) |
| void | extendExtractDigits (std::vector< Ctxt > &digits, const Ctxt &c, long r, long e) |
| void | setupDebugGlobals (SecKey *debug_key, const std::shared_ptr< const EncryptedArray > &debug_ea, NTL::ZZX debug_ptxt=NTL::ZZX{}) |
| Setup function for setting up the global debug variables. More... | |
| void | cleanupDebugGlobals () |
| Cleanup function for clearing the global debug variables. More... | |
| void | decryptAndPrint (std::ostream &s, const Ctxt &ctxt, const SecKey &sk, const EncryptedArray &ea, long flags=0) |
| NTL::xdouble | embeddingLargestCoeff (const Ctxt &ctxt, const SecKey &sk) |
| double | realToEstimatedNoise (const Ctxt &ctxt, const SecKey &sk) |
| void | checkNoise (const Ctxt &ctxt, const SecKey &sk, const std::string &msg, double thresh=10.0) |
| bool | decryptAndCompare (const Ctxt &ctxt, const SecKey &sk, const EncryptedArray &ea, const PlaintextArray &pa) |
| void | rawDecrypt (NTL::ZZX &plaintxt, const std::vector< NTL::ZZX > &zzParts, const DoubleCRT &sKey, long q=0) |
| template<typename VEC > | |
| std::ostream & | printVec (std::ostream &s, const VEC &v, long nCoeffs=40) |
| std::ostream & | printZZX (std::ostream &s, const NTL::ZZX &poly, long nCoeffs=40) |
| void | conv (DoubleCRT &d, const NTL::ZZX &p) |
| void | conv (NTL::ZZX &p, const DoubleCRT &d) |
| NTL::ZZX | to_ZZX (const DoubleCRT &d) |
| template<typename RX , typename RXModulus > | |
| void | plaintextAutomorph (RX &bb, const RX &a, long k, long m, const RXModulus &PhimX) |
| template<typename RX , typename type > | |
| void | plaintextAutomorph (RX &b, const RX &a, long i, long j, const EncryptedArrayDerived< type > &ea) |
| EncryptedArrayBase * | buildEncryptedArray (const Context &context, const PAlgebraMod &alMod, const NTL::ZZX &G=NTL::ZZX::zero()) |
| A "factory" for building EncryptedArrays. More... | |
| std::ostream & | operator<< (std::ostream &s, const PlaintextArray &pa) |
| void | rotate (const EncryptedArray &ea, PlaintextArray &pa, long k) |
| void | shift (const EncryptedArray &ea, PlaintextArray &pa, long k) |
| void | encode (const EncryptedArray &ea, PlaintextArray &pa, const std::vector< long > &array) |
| void | encode (const EncryptedArray &ea, PlaintextArray &pa, const std::vector< NTL::ZZX > &array) |
| void | encode (const EncryptedArray &ea, PlaintextArray &pa, long val) |
| void | encode (const EncryptedArray &ea, PlaintextArray &pa, const NTL::ZZX &val) |
| void | random (const EncryptedArray &ea, PlaintextArray &pa) |
| void | decode (const EncryptedArray &ea, std::vector< long > &array, const PlaintextArray &pa) |
| void | decode (const EncryptedArray &ea, std::vector< NTL::ZZX > &array, const PlaintextArray &pa) |
| bool | equals (const EncryptedArray &ea, const PlaintextArray &pa, const PlaintextArray &other) |
| bool | equals (const EncryptedArray &ea, const PlaintextArray &pa, const std::vector< long > &other) |
| bool | equals (const EncryptedArray &ea, const PlaintextArray &pa, const std::vector< NTL::ZZX > &other) |
| void | add (const EncryptedArray &ea, PlaintextArray &pa, const PlaintextArray &other) |
| void | sub (const EncryptedArray &ea, PlaintextArray &pa, const PlaintextArray &other) |
| void | mul (const EncryptedArray &ea, PlaintextArray &pa, const PlaintextArray &other) |
| void | negate (const EncryptedArray &ea, PlaintextArray &pa) |
| void | frobeniusAutomorph (const EncryptedArray &ea, PlaintextArray &pa, long j) |
| void | frobeniusAutomorph (const EncryptedArray &ea, PlaintextArray &pa, const NTL::Vec< long > &vec) |
| void | applyPerm (const EncryptedArray &ea, PlaintextArray &pa, const NTL::Vec< long > &pi) |
| void | power (const EncryptedArray &ea, PlaintextArray &pa, long e) |
| void | runningSums (const EncryptedArray &ea, Ctxt &ctxt) |
A ctxt that encrypts  is replaced by an encryption of  , where  . More... | |
| void | print_stats (std::ostream &s) |
| const std::vector< double > * | fetch_saved_values (const char *) |
| std::ostream & | operator<< (std::ostream &s, const CubeSignature &sig) |
| template<typename T > | |
| void | getHyperColumn (NTL::Vec< T > &v, const ConstCubeSlice< T > &s, long pos) |
| template<typename T > | |
| void | setHyperColumn (const NTL::Vec< T > &v, const CubeSlice< T > &s, long pos) |
| template<typename T > | |
| void | setHyperColumn (const NTL::Vec< T > &v, const CubeSlice< T > &s, long pos, const T &val) |
| template<typename T > | |
| void | print3D (const HyperCube< T > &c) |
| template<typename T > | |
| bool | operator== (const IndexMap< T > &map1, const IndexMap< T > &map2) |
| Comparing maps, by comparing all the elements. More... | |
| template<typename T > | |
| bool | operator!= (const IndexMap< T > &map1, const IndexMap< T > &map2) |
| IndexSet | operator| (const IndexSet &s, const IndexSet &t) |
| union More... | |
| IndexSet | operator& (const IndexSet &s, const IndexSet &t) |
| intersection More... | |
| IndexSet | operator^ (const IndexSet &s, const IndexSet &t) |
| exclusive-or More... | |
| IndexSet | operator/ (const IndexSet &s, const IndexSet &t) |
| set minus More... | |
| std::ostream & | operator<< (std::ostream &str, const IndexSet &set) |
| std::istream & | operator>> (std::istream &str, IndexSet &set) |
| long | card (const IndexSet &s) |
| Functional cardinality. More... | |
| bool | empty (const IndexSet &s) |
| bool | operator<= (const IndexSet &s1, const IndexSet &s2) |
| Is s1 subset or equal to s2. More... | |
| bool | operator< (const IndexSet &s1, const IndexSet &s2) |
| Is s1 strict subset of s2. More... | |
| bool | operator>= (const IndexSet &s1, const IndexSet &s2) |
| Is s2 subset or equal to s2. More... | |
| bool | operator> (const IndexSet &s1, const IndexSet &s2) |
| Is s2 strict subset of s1. More... | |
| bool | disjoint (const IndexSet &s1, const IndexSet &s2) |
| Functional disjoint. More... | |
| void | buildUnpackSlotEncoding (std::vector< zzX > &unpackSlotEncoding, const EncryptedArray &ea) |
| void | unpack (const CtPtrs &unpacked, const Ctxt &packed, const EncryptedArray &ea, const std::vector< zzX > &unpackSlotEncoding) |
| long | unpack (const CtPtrs &unpacked, const CtPtrs &packed, const EncryptedArray &ea, const std::vector< zzX > &unpackSlotEncoding) |
| void | repack (Ctxt &packed, const CtPtrs &unpacked, const EncryptedArray &ea) |
| long | repack (const CtPtrs &packed, const CtPtrs &unpacked, const EncryptedArray &ea) |
| void | unpackSlots (std::vector< std::size_t > &value, PlaintextArray &pa, const EncryptedArray &ea) |
| void | unpackSlots (std::vector< std::size_t > &value, NTL::ZZX &pa, const EncryptedArray &ea) |
| void | packConstant (zzX &result, unsigned long data, long nbits, const EncryptedArray &ea) |
| void | packConstants (zzX &result, const std::vector< std::size_t > &data, long nbits, const EncryptedArray &ea) |
| void | writePubKeyBinary (std::ostream &str, const PubKey &pk) |
| void | readPubKeyBinary (std::istream &str, PubKey &pk) |
| void | writeSecKeyBinary (std::ostream &str, const SecKey &sk) |
| void | readSecKeyBinary (std::istream &str, SecKey &sk) |
| double | RLWE (DoubleCRT &c0, DoubleCRT &c1, const DoubleCRT &s, long p, NTL::ZZ *prgSeed=nullptr) |
| double | RLWE1 (DoubleCRT &c0, const DoubleCRT &c1, const DoubleCRT &s, long p) |
| Same as RLWE, but assumes that c1 is already chosen by the caller. More... | |
| std::ostream & | operator<< (std::ostream &str, const KeySwitch &matrix) |
| void | Warning (const char *msg) |
| Function for logging a warning message. More... | |
| void | Warning (const std::string &msg) |
| Function for logging a warning message. More... | |
| long | maximum_flow (FlowGraph &fg, long src, long sink) |
| void | traceMap (Ctxt &ctxt) |
| void | mul (PlaintextArray &pa, const MatMul1D &mat) |
| void | mul (PlaintextArray &pa, const BlockMatMul1D &mat) |
| void | mul (PlaintextArray &pa, const MatMulFull &mat) |
| void | mul (PlaintextArray &pa, const BlockMatMulFull &mat) |
| template<typename T , typename T2 , typename std::enable_if_t< std::is_convertible< T, std::size_t >::value > * = nullptr> | |
| Tensor< T, 2 > | operator* (const Tensor< T, 2 > &M1, const Tensor< T2, 2 > &M2) |
| template<typename T > | |
| void | printMatrix (const Matrix< T > &M, std::ostream &out=std::cout) |
| long | sumOfCoeffs (const zzX &f) |
| NTL::ZZ | sumOfCoeffs (const NTL::ZZX &f) |
| NTL::ZZ | sumOfCoeffs (const DoubleCRT &f) |
| template<typename T > | |
| double | largestCoeff (const NTL::Vec< T > &f) |
| The L-infinity norm of an element (in coefficient representation) More... | |
| template<typename T > | |
| double | largestCoeff (const std::vector< T > &f) |
| NTL::ZZ | largestCoeff (const NTL::ZZX &f) |
| NTL::ZZ | largestCoeff (const NTL::Vec< NTL::ZZ > &f) |
| NTL::ZZ | largestCoeff (const DoubleCRT &f) |
| double | coeffsL2NormSquared (const zzX &f) |
| The L2-norm of an element (in coefficient representation) More... | |
| NTL::xdouble | coeffsL2NormSquared (const NTL::ZZX &f) |
| NTL::xdouble | coeffsL2NormSquared (const DoubleCRT &f) |
| double | coeffsL2Norm (const zzX &f) |
| NTL::xdouble | coeffsL2Norm (const NTL::ZZX &f) |
| NTL::xdouble | coeffsL2Norm (const DoubleCRT &f) |
| double | embeddingLargestCoeff (const zzX &f, const PAlgebra &palg) |
| double | embeddingLargestCoeff (const std::vector< double > &f, const PAlgebra &palg) |
| void | embeddingLargestCoeff_x2 (double &norm1, double &norm2, const std::vector< double > &f1, const std::vector< double > &f2, const PAlgebra &palg) |
| NTL::xdouble | embeddingLargestCoeff (const NTL::ZZX &f, const PAlgebra &palg) |
| void | CKKS_canonicalEmbedding (std::vector< cx_double > &v, const zzX &f, const PAlgebra &palg) |
| void | CKKS_canonicalEmbedding (std::vector< cx_double > &v, const NTL::ZZX &f, const PAlgebra &palg) |
| void | CKKS_canonicalEmbedding (std::vector< cx_double > &v, const std::vector< double > &f, const PAlgebra &palg) |
| void | CKKS_embedInSlots (zzX &f, const std::vector< cx_double > &v, const PAlgebra &palg, double scaling) |
| bool | setDryRun (bool toWhat=true) |
| bool | isDryRun () |
| void | setAutomorphVals (std::set< long > *aVals) |
| bool | isSetAutomorphVals () |
| void | recordAutomorphVal (long k) |
| void | setAutomorphVals2 (std::set< long > *aVals) |
| bool | isSetAutomorphVals2 () |
| void | recordAutomorphVal2 (long k) |
| long | bitSetToLong (long bits, long bitSize) |
Considers bits as a vector of bits and returns the value it represents when interpreted as a n-bit 2's complement number, where n is given by bitSize. More... | |
| long | mcMod (long a, long b) |
| Routines for computing mathematically correct mod and div. More... | |
| long | mcDiv (long a, long b) |
| long | balRem (long a, long q) |
| double | fsquare (double x) |
| Return the square of a number as a double. More... | |
| long | multOrd (long p, long m) |
| Return multiplicative order of p modulo m, or 0 if GCD(p, m) != 1. More... | |
| void | ppsolve (NTL::vec_zz_pE &x, const NTL::mat_zz_pE &A, const NTL::vec_zz_pE &b, long p, long r) |
| Prime power solver. More... | |
| void | ppsolve (NTL::vec_GF2E &x, const NTL::mat_GF2E &A, const NTL::vec_GF2E &b, long p, long r) |
| A version for GF2: must have p == 2 and r == 1. More... | |
| void | ppInvert (NTL::mat_zz_p &X, const NTL::mat_zz_p &A, long p, long r) |
| Compute the inverse mod p^r of an n x n matrix. More... | |
| void | ppInvert (NTL::mat_zz_pE &X, const NTL::mat_zz_pE &A, long p, long r) |
| void | ppInvert (NTL::mat_GF2 &X, const NTL::mat_GF2 &A, UNUSED long p, UNUSED long r) |
| void | ppInvert (NTL::mat_GF2E &X, const NTL::mat_GF2E &A, UNUSED long p, UNUSED long r) |
| void | buildLinPolyMatrix (NTL::mat_zz_pE &M, long p) |
| void | buildLinPolyMatrix (NTL::mat_GF2E &M, long p) |
| void | buildLinPolyCoeffs (NTL::vec_zz_pE &C, const NTL::vec_zz_pE &L, long p, long r) |
| Combination of buildLinPolyMatrix and ppsolve. More... | |
| void | buildLinPolyCoeffs (NTL::vec_GF2E &C, const NTL::vec_GF2E &L, long p, long r) |
| A version for GF2: must be called with p == 2 and r == 1. More... | |
| void | applyLinPoly (NTL::zz_pE &beta, const NTL::vec_zz_pE &C, const NTL::zz_pE &alpha, long p) |
| Apply a linearized polynomial with coefficient vector C. More... | |
| void | applyLinPoly (NTL::GF2E &beta, const NTL::vec_GF2E &C, const NTL::GF2E &alpha, long p) |
| A version for GF2: must be called with p == 2 and r == 1. More... | |
| double | log2 (const NTL::xdouble &x) |
| Base-2 logarithm. More... | |
| void | factorize (std::vector< long > &factors, long N) |
| Factoring by trial division, only works for N<2^{60}, only the primes are recorded, not their multiplicity. More... | |
| void | factorize (std::vector< NTL::ZZ > &factors, const NTL::ZZ &N) |
| void | factorize (NTL::Vec< NTL::Pair< long, long >> &factors, long N) |
| Factoring by trial division, only works for N<2^{60} primes and multiplicities are recorded. More... | |
| void | pp_factorize (std::vector< long > &factors, long N) |
| Prime-power factorization. More... | |
| void | phiN (long &phiN, std::vector< long > &facts, long N) |
| Compute Phi(N) and also factorize N. More... | |
| void | phiN (NTL::ZZ &phiN, std::vector< NTL::ZZ > &facts, const NTL::ZZ &N) |
| long | phi_N (long N) |
| Compute Phi(N). More... | |
| long | findGenerators (std::vector< long > &gens, std::vector< long > &ords, long m, long p, const std::vector< long > &candidates=std::vector< long >()) |
| void | FindPrimitiveRoot (NTL::zz_p &r, unsigned long e) |
| Find e-th root of unity modulo the current modulus. More... | |
| void | FindPrimitiveRoot (NTL::ZZ_p &r, unsigned long e) |
| long | mobius (long n) |
| Compute mobius function (naive method as n is small). More... | |
| NTL::ZZX | Cyclotomic (long N) |
| Compute cyclotomic polynomial. More... | |
| NTL::ZZX | makeIrredPoly (long p, long d) |
| Return a degree-d irreducible polynomial mod p. More... | |
| long | primroot (long N, long phiN) |
| Find a primitive root modulo N. More... | |
| long | ord (long N, long p) |
| Compute the highest power of p that divides N. More... | |
| bool | is2power (long m) |
| NTL::ZZX | RandPoly (long n, const NTL::ZZ &p) |
| void | MulMod (NTL::ZZX &out, const NTL::ZZX &f, long a, long q, bool abs) |
| void | MulMod (NTL::ZZX &out, const NTL::ZZX &f, long a, long q) |
| NTL::ZZX | MulMod (const NTL::ZZX &f, long a, long q, bool abs) |
| NTL::ZZX | MulMod (const NTL::ZZX &f, long a, long q) |
| void | balanced_MulMod (NTL::ZZX &out, const NTL::ZZX &f, long a, long q) |
| template<typename T1 , typename T2 > | |
| void | convert (T1 &x1, const T2 &x2) |
| A generic template that resolves to NTL's conv routine. More... | |
| template<typename T1 , typename T2 > | |
| void | convert (std::vector< T1 > &v1, const std::vector< T2 > &v2) |
| generic vector conversion routines More... | |
| template<typename T1 , typename T2 > | |
| void | convert (std::vector< T1 > &v1, const NTL::Vec< T2 > &v2) |
| template<typename T1 , typename T2 > | |
| void | convert (NTL::Vec< T1 > &v1, const std::vector< T2 > &v2) |
| template<typename T > | |
| void | convert (std::vector< T > &v1, const std::vector< T > &v2) |
| Trivial type conversion, useful for generic code. More... | |
| template<typename T1 , typename T2 > | |
| T1 | convert (const T2 &v2) |
| template<typename T > | |
| std::vector< T > | vector_replicate (const T &a, long n) |
| template<typename T > | |
| std::vector< T > | Vec_replicate (const T &a, long n) |
| long | computeProd (const NTL::Vec< long > &vec) |
| returns \prod_d vec[d] More... | |
| long | computeProd (const std::vector< long > &vec) |
| void | mul (std::vector< NTL::ZZX > &x, const std::vector< NTL::ZZX > &a, long b) |
| void | div (std::vector< NTL::ZZX > &x, const std::vector< NTL::ZZX > &a, long b) |
| void | add (std::vector< NTL::ZZX > &x, const std::vector< NTL::ZZX > &a, const std::vector< NTL::ZZX > &b) |
| long | is_in (long x, int *X, long sz) |
| Finds whether x is an element of the set X of size sz, Returns -1 it not and the location if true. More... | |
| long | CRTcoeff (long p, long q, bool symmetric=false) |
| Returns a CRT coefficient: x = (0 mod p, 1 mod q). If symmetric is set then x \in [-pq/2, pq/2), else x \in [0,pq) More... | |
| template<class zzvec > | |
| bool | intVecCRT (NTL::vec_ZZ &vp, const NTL::ZZ &p, const zzvec &vq, long q) |
| Incremental integer CRT for vectors. More... | |
| template<typename T , bool maxFlag> | |
| long | argminmax (std::vector< T > &v) |
| Find the index of the (first) largest/smallest element. More... | |
| template<typename T > | |
| long | argmax (std::vector< T > &v) |
| template<typename T > | |
| long | argmin (std::vector< T > &v) |
| long | argmax (std::vector< long > &v, bool(*moreThan)(long, long)) |
| A variant with a specialized comparison function (*moreThan)(a,b) returns the comparison a>b. More... | |
| bool | closeToOne (const NTL::xdouble &x, long p) |
| std::pair< long, long > | rationalApprox (double x, long denomBound=0) |
| std::pair< NTL::ZZ, NTL::ZZ > | rationalApprox (NTL::xdouble x, NTL::xdouble denomBound=NTL::xdouble(0.0)) |
| void | seekPastChar (std::istream &str, int cc) |
| Advance the input stream beyond white spaces and a single instance of the char cc. More... | |
| bool | iterateInterestRegion (std::istream &str, int begin_char, int separator, int end_char) |
Advance the input stream str beyond white spaces and a single separator in the region-of-interest delimited by begin_char and end_char. More... | |
| std::vector< std::stringstream > | extractTokenizeRegion (std::istream &istr, char begin_char, char end_char, char separator, bool skip_space=true) |
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. More... | |
| template<typename T > | |
| void | reverse (NTL::Vec< T > &v, long lo, long hi) |
| Reverse a vector in place. More... | |
| template<typename T > | |
| void | rotate (NTL::Vec< T > &v, long k) |
| Rotate a vector in place using swaps. More... | |
| template<typename T > | |
| long | lsize (const std::vector< T > &v) |
| Size of STL vector as a long (rather than unsigned long) More... | |
| template<typename T > | |
| void | killVec (std::vector< T > &vec) |
| NTL/std compatibility. More... | |
| template<typename T > | |
| void | killVec (NTL::Vec< T > &vec) |
| template<typename T > | |
| void | setLengthZero (std::vector< T > &vec) |
| template<typename T > | |
| void | setLengthZero (NTL::Vec< T > &vec) |
| template<typename T > | |
| long | lsize (const NTL::Vec< T > &v) |
| template<typename T > | |
| void | resize (NTL::Vec< T > &v, long sz, const T &val) |
| template<typename T > | |
| void | resize (std::vector< T > &v, long sz, const T &val) |
| template<typename T > | |
| void | resize (NTL::Vec< T > &v, long sz) |
| template<typename T > | |
| void | resize (std::vector< T > &v, long sz) |
| template<typename T1 , typename T2 > | |
| bool | sameObject (const T1 *p1, const T2 *p2) |
| Testing if two vectors point to the same object. More... | |
| void | ModComp (NTL::ZZX &res, const NTL::ZZX &g, const NTL::ZZX &h, const NTL::ZZX &f) |
| Modular composition of polynomials: res = g(h) mod f. More... | |
| long | polyEvalMod (const NTL::ZZX &poly, long x, long p) |
| Evaluates a modular integer polynomial, returns poly(x) mod p. More... | |
| void | interpolateMod (NTL::ZZX &poly, const NTL::vec_long &x, const NTL::vec_long &y, long p, long e=1) |
| Interpolate polynomial such that poly(x[i] mod p)=y[i] (mod p^e) It is assumed that the points x[i] are all distinct modulo p. More... | |
| long | divc (long a, long b) |
| returns ceiling(a/b); assumes a >=0, b>0, a+b <= MAX_LONG More... | |
| void | rem (NTL::zz_pX &r, const NTL::zz_pX &a, const zz_pXModulus1 &ff) |
| template<typename T > | |
| std::ostream & | operator<< (std::ostream &s, std::vector< T > v) |
| template<typename T > | |
| std::istream & | operator>> (std::istream &s, std::vector< T > &v) |
| template<typename T > | |
| std::string | vecToStr (const std::vector< T > &v) |
| template<typename T > | |
| NTL::Vec< T > | atoVec (const char *a) |
| template<typename T > | |
| std::vector< T > | atovector (const char *a) |
| void | TofftRep_trunc (NTL::fftRep &y, const NTL::zz_pX &x, long k, UNUSED long len, long lo, long hi) |
| void | TofftRep_trunc (NTL::fftRep &y, const NTL::zz_pX &x, long k, long len) |
| double | max_abs (const std::vector< std::complex< double >> &vec) |
| double | max_abs (const std::vector< double > &vec) |
| template<typename T , typename P , typename... Args> | |
| void | make_lazy (const NTL::Lazy< T, P > &obj, Args &&... args) |
| template<typename T , typename P , typename F , typename... Args> | |
| void | make_lazy_with_fun (const NTL::Lazy< T, P > &obj, F f, Args &&... args) |
| PAlgebraModBase * | buildPAlgebraMod (const PAlgebra &zMStar, long r) |
| Builds a table, of type PA_GF2 if p == 2 and r == 1, and PA_zz_p otherwise. More... | |
| bool | comparePAlgebra (const PAlgebra &palg, unsigned long m, unsigned long p, unsigned long r, const std::vector< long > &gens, const std::vector< long > &ords) |
| returns true if the palg parameters match the rest, false otherwise More... | |
| double | calcPolyNormBnd (long m) |
| template<typename TXT > | |
| Matrix< TXT > | calculateMasks (const EncryptedArray &ea, Matrix< TXT > query, const Matrix< Ptxt< BGV >> &database) |
| Given a query set and a database, calculates a mask of {0,1} where 1 signifies a matching element and 0 otherwise. More... | |
| template<typename TXT > | |
| Matrix< Ctxt > | calculateMasks (const EncryptedArray &ea, Matrix< TXT > query, const Matrix< Ctxt > &database) |
| Given a query set and a database, calculates a mask of {0,1} where 1 signifies a matching element and 0 otherwise. More... | |
| template<typename TXT > | |
| Matrix< TXT > | calculateScores (const std::vector< std::vector< long >> index_sets, const std::vector< long > &offsets, const std::vector< Matrix< long >> &weights, const Matrix< TXT > &mask) |
| Given a mask and information about the query to be performed, calculates a score for each matching element signified by the mask. More... | |
| PolyMod | partialMatchEncode (uint32_t input, const Context &context) |
| Given a value, encode the value across the coefficients of a polynomial. More... | |
| std::shared_ptr< ColNumber > | makeQueryExpr (int cl) |
| Utility function for creating a shared pointer to a specified column in a query. More... | |
| std::shared_ptr< And > | operator&& (const QueryExpr &lhs, const QueryExpr &rhs) |
| Overloaded operator for creating a shared pointer to an AND expression. More... | |
| std::shared_ptr< Or > | operator|| (const QueryExpr &lhs, const QueryExpr &rhs) |
| Overloaded operator for creating a shared pointer to an OR expression. More... | |
| template<typename T > | |
| void | applyPermToVec (NTL::Vec< T > &out, const NTL::Vec< T > &in, const Permut &p1) |
| Apply a permutation to a std::vector, out[i]=in[p1[i]] (NOT in-place) More... | |
| template<typename T > | |
| void | applyPermToVec (std::vector< T > &out, const std::vector< T > &in, const Permut &p1) |
| template<typename T > | |
| void | applyPermsToVec (NTL::Vec< T > &out, const NTL::Vec< T > &in, const Permut &p2, const Permut &p1) |
| Apply two permutations to a std::vector out[i]=in[p2[p1[i]]] (NOT in-place) More... | |
| template<typename T > | |
| void | applyPermsToVec (std::vector< T > &out, const std::vector< T > &in, const Permut &p2, const Permut &p1) |
| void | randomPerm (Permut &perm, long n) |
| A random size-n permutation. More... | |
| std::ostream & | operator<< (std::ostream &s, const ColPerm &p) |
| void | breakPermByDim (std::vector< ColPerm > &out, const Permut &pi, const CubeSignature &sig) |
| Takes a permutation pi over m-dimensional cube C=Z_{n1} x...x Z_{nm} and expresses pi as a product pi = rho_{2m-1} o ... o rho_2 o rho_1 where each rho_i is a column permutation along one dimension. Specifically for i<m, the permutations rho_i and rho_{2(m-1)-i} permute the i'th dimension. More... | |
| void | polyEval (Ctxt &ret, NTL::ZZX poly, const Ctxt &x, long k=0) |
| Evaluate a cleartext polynomial on an encrypted input. More... | |
| void | polyEval (Ctxt &ret, const NTL::Vec< Ctxt > &poly, const Ctxt &x) |
| Evaluate an encrypted polynomial on an encrypted input. More... | |
| std::ostream & | operator<< (std::ostream &s, const ModuliSizes::Entry &e) |
| std::istream & | operator>> (std::istream &s, ModuliSizes::Entry &e) |
| void | write (std::ostream &s, const ModuliSizes::Entry &e) |
| void | read (std::istream &s, ModuliSizes::Entry &e) |
| template<typename T > | |
| long | lsize (const PtrMatrix< T > &v) |
| template<typename T > | |
| void | resize (PtrMatrix< T > &v, long newSize) |
| template<typename T > | |
| void | setLengthZero (PtrMatrix< T > &v) |
| template<typename T > | |
| const T * | ptr2nonNull (std::initializer_list< const PtrVector< T > * > list) |
| template<typename T > | |
| long | lsize (const PtrVector< T > &v) |
| template<typename T > | |
| void | setLengthZero (PtrVector< T > &v) |
| template<typename T > | |
| void | resize (PtrVector< T > &v, long newSize, const T &val) |
| template<typename T > | |
| void | resize (PtrVector< T > &v, long newSize, const T *val) |
| template<typename V1 , typename V2 > | |
| void | vecCopy (V1 &v1, const V2 &v2, long sizeLimit=0) |
| template<typename V , typename T > | |
| void | vecCopy (V &v1, const PtrVector< T > &v2, long sizeLimit=0) |
| template<typename V , typename T > | |
| void | vecCopy (PtrVector< T > &v1, const V &v2, long sizeLimit=0) |
| template<typename T > | |
| void | vecCopy (PtrVector< T > &v1, const PtrVector< T > &v2, long sizeLimit=0) |
| template<typename From , typename Scheme > | |
| std::vector< typename Scheme::SlotType > | convertDataToSlotVector (const std::vector< From > &data, const Context &context) |
Converts std::vector<From> to std::vector<Scheme::SlotType>. More... | |
| template<typename Scheme > | |
| void | innerProduct (Ptxt< Scheme > &result, const std::vector< Ptxt< Scheme >> &first_vec, const std::vector< Ptxt< Scheme >> &second_vec) |
Free function that computes the inner product of two vectors of Ptxt. More... | |
| void | deserialize (std::istream &is, std::complex< double > &num) |
Deserialize a std::complex<double> from the input stream is delimited by '[' and ']' (instead of the default '(', ')'). More... | |
| void | serialize (std::ostream &os, const std::complex< double > &num) |
Serialize a std::complex<double> to the output stream os delimited by '[' and ']' (instead of the default '(', ')'). More... | |
| template<typename Scheme > | |
| void | deserialize (std::istream &is, Ptxt< Scheme > &ptxt) |
Function to deserialize a Ptxt<Scheme>. More... | |
| template<typename Scheme > | |
| void | serialize (std::ostream &os, const Ptxt< Scheme > &ptxt) |
Function to serialize a Ptxt<Scheme>. More... | |
| template<typename Scheme > | |
| std::istream & | operator>> (std::istream &is, Ptxt< Scheme > &ptxt) |
Input shift operator. Uses the deserialize function internally. More... | |
| template<typename Scheme > | |
| std::ostream & | operator<< (std::ostream &is, const Ptxt< Scheme > &ptxt) |
Output shift operator. Uses the serialize function internally. More... | |
| MatMul1D * | buildRandomMatrix (const EncryptedArray &ea, long dim) |
| MatMul1D * | buildRandomMultiMatrix (const EncryptedArray &ea, long dim) |
| BlockMatMul1D * | buildRandomBlockMatrix (const EncryptedArray &ea, long dim) |
| BlockMatMul1D * | buildRandomMultiBlockMatrix (const EncryptedArray &ea, long dim) |
| MatMulFull * | buildRandomFullMatrix (const EncryptedArray &ea) |
| BlockMatMulFull * | buildRandomFullBlockMatrix (const EncryptedArray &ea) |
| general_range< long > | range (long n) |
| general_range< long > | range (long m, long n) |
| void | replicate (const EncryptedArray &ea, Ctxt &ctx, long pos) |
| The value in slot #pos is replicated in all other slots. On an n-slot ciphertext, this algorithm performs O(log n) 1D rotations. More... | |
| void | replicate0 (const EncryptedArray &ea, Ctxt &ctxt, long pos) |
| A lower-level routine. Same as replicate, but assumes all slots are zero except slot #pos. More... | |
| void | replicateAll (const EncryptedArray &ea, const Ctxt &ctxt, ReplicateHandler *handler, long recBound=64, RepAuxDim *repAuxPtr=nullptr) |
| void | replicateAll (std::vector< Ctxt > &v, const EncryptedArray &ea, const Ctxt &ctxt, long recBound=64, RepAuxDim *repAuxPtr=nullptr) |
| template<typename Scheme > | |
| void | replicateAll (std::vector< Ptxt< Scheme >> &v, const EncryptedArray &, const Ptxt< Scheme > &ptxt) |
| Generate a vector of plaintexts with each slot replicated in each plaintext. More... | |
| void | replicateAllOrig (const EncryptedArray &ea, const Ctxt &ctxt, ReplicateHandler *handler, RepAux *repAuxPtr=nullptr) |
| void | replicate (const EncryptedArray &ea, PlaintextArray &pa, long i) |
| template<typename Scheme > | |
| void | replicate (const EncryptedArray &, Ptxt< Scheme > &ptxt, long i) |
Replicate single slot of a Ptxt object across all of its slots. More... | |
| void | sampleSmall (zzX &poly, long n, double prob=0.5) |
| void | sampleSmall (NTL::ZZX &poly, long n, double prob=0.5) |
| void | sampleHWt (zzX &poly, long n, long Hwt=100) |
| Sample a degree-(n-1) poly as above, with only Hwt nonzero coefficients. More... | |
| void | sampleHWt (NTL::ZZX &poly, long n, long Hwt=100) |
| void | sampleGaussian (zzX &poly, long n, double stdev) |
| Sample polynomials with Gaussian coefficients. More... | |
| void | sampleGaussian (NTL::ZZX &poly, long n, double stdev) |
| void | sampleUniform (zzX &poly, long n, long B=100) |
| Sample a degree-(n-1) ZZX, with coefficients uniform in [-B,B]. More... | |
| void | sampleUniform (NTL::ZZX &poly, long n, const NTL::ZZ &B=NTL::ZZ(100L)) |
| void | sampleGaussian (std::vector< double > &dvec, long n, double stdev) |
| Choose a vector of continuous Gaussians. More... | |
| double | sampleHWt (zzX &poly, const Context &context, long Hwt=100) |
| double | sampleHWtBounded (zzX &poly, const Context &context, long Hwt=100) |
| double | sampleHWtBoundedEffectiveBound (const Context &context, long Hwt=100) |
| double | sampleSmall (zzX &poly, const Context &context) |
| double | sampleSmallBounded (zzX &poly, const Context &context) |
| double | sampleGaussian (zzX &poly, const Context &context, double stdev) |
| double | sampleGaussianBounded (zzX &poly, const Context &context, double stdev) |
| double | sampleUniform (zzX &poly, const Context &context, long B=100) |
| NTL::xdouble | sampleUniform (NTL::ZZX &poly, const Context &context, const NTL::ZZ &B=NTL::ZZ(100L)) |
| void | reduceModPhimX (zzX &poly, const PAlgebra &palg) |
| const NTL::zz_pXModulus & | getPhimXMod (const PAlgebra &palg) |
| template<typename TXT > | |
| void | binSumReduction (std::vector< TXT > &ctxtArray) |
| Performs a binary summation of a vector of elements. More... | |
| template<typename TXT > | |
| TXT | calculateSetIntersection (const TXT &query, const std::vector< NTL::ZZX > &server_set) |
| Given two sets, calculates and returns the set intersection. More... | |
| void | computeAllProducts (CtPtrs &products, const CtPtrs &array, std::vector< zzX > *unpackSlotEncoding=nullptr) |
| void | tableLookup (Ctxt &out, const std::vector< zzX > &table, const CtPtrs &idx, std::vector< zzX > *unpackSlotEncoding=nullptr) |
| void | tableWriteIn (const CtPtrs &table, const CtPtrs &idx, std::vector< zzX > *unpackSlotEncoding=nullptr) |
| void | buildLookupTable (std::vector< zzX > &T, std::function< double(double)> f, long nbits_in, long scale_in, long sign_in, long nbits_out, long scale_out, long sign_out, const EncryptedArray &ea) |
| Built a table-lookup for a function in fixed-point representation. More... | |
| void | registerTimer (FHEtimer *timer) |
| unsigned long | GetTimerClock () |
| void | setTimersOn () |
| void | setTimersOff () |
| bool | areTimersOn () |
| const FHEtimer * | getTimerByName (const char *name) |
| void | resetAllTimers () |
| void | printAllTimers (std::ostream &str=std::cerr) |
| Print the value of all timers to stream. More... | |
| bool | printNamedTimer (std::ostream &str, const char *name) |
| template<typename T > | |
| T | zeroValue (const T &x) |
Given an object x return a zero object of the same type. More... | |
| template<> | |
| Ctxt | zeroValue< Ctxt > (const Ctxt &x) |
Given a Ctxt return a zero object of the same type. More... | |
| template<> | |
| Ptxt< BGV > | zeroValue< Ptxt< BGV > > (const Ptxt< BGV > &x) |
Given a Ptxt<BGV> return a zero object of the same type. More... | |
| template<> | |
| Ptxt< CKKS > | zeroValue< Ptxt< CKKS > > (const Ptxt< CKKS > &x) |
Given a Ptxt<CKKS> return a zero object of the same type. More... | |
| bool | IsZero (const zzX &a) |
| void | clear (zzX &a) |
| void | convert (NTL::zz_pX &x, const zzX &a) |
| void | add (zzX &res, const zzX &a, const zzX &b) |
| zzX | operator+ (const zzX &a, const zzX &b) |
| zzX & | operator+= (zzX &a, const zzX &b) |
| void | div (zzX &res, const zzX &a, long b) |
| zzX | operator/ (const zzX &a, long b) |
| zzX & | operator/= (zzX &a, long b) |
| void | mul (zzX &res, const zzX &a, long b) |
| zzX | operator* (const zzX &a, long b) |
| zzX & | operator*= (zzX &a, long b) |
| void | normalize (zzX &f) |
| void | MulMod (zzX &res, const zzX &a, const zzX &b, const PAlgebra &palg) |
| zzX | MulMod (const zzX &a, const zzX &b, const PAlgebra &palg) |
| zzX | balanced_zzX (const NTL::zz_pX &f) |
| zzX | balanced_zzX (const NTL::GF2X &f) |
| long | defaultPmiddle (long delta) |
| long | defaultQmiddle (long delta) |
| void | runningSums (CtPtrs &v) |
| void | compareTwoNumbersImplementation (CtPtrs &max, CtPtrs &min, Ctxt &mu, Ctxt &ni, const CtPtrs &aa, const CtPtrs &bb, bool twosComplement, std::vector< zzX > *unpackSlotEncoding, bool cmp_only) |
| void | BluesteinFFT (NTL::zz_pX &x, long n, UNUSED const NTL::zz_p &root, const NTL::zz_pX &powers, const NTL::Vec< NTL::mulmod_precon_t > &powers_aux, const NTL::fftRep &Rb) |
| NTL::zz_pContext | BuildContext (long p, long maxroot) |
| std::ostream & | operator<< (std::ostream &str, const Context &context) |
| std::istream & | operator>> (std::istream &str, Context &context) |
| NTL::ZZX | getG (const EncryptedArray &ea) |
| void | addSomePrimes (Ctxt &c) |
| void | computeIntervalForMul (double &lo, double &hi, const Ctxt &ctxt1, const Ctxt &ctxt2) |
| void | computeIntervalForSqr (double &lo, double &hi, const Ctxt &ctxt) |
| std::istream & | operator>> (std::istream &str, SKHandle &handle) |
| std::ostream & | operator<< (std::ostream &str, const Ctxt &ctxt) |
| std::istream & | operator>> (std::istream &str, Ctxt &ctxt) |
| double | log2_realToEstimatedNoise (const Ctxt &ctxt, const SecKey &sk) |
| template DoubleCRT & | DoubleCRT::Op< DoubleCRT::AddFun > (const DoubleCRT &other, AddFun fun, bool matchIndexSets) |
| template DoubleCRT & | DoubleCRT::Op< DoubleCRT::SubFun > (const DoubleCRT &other, SubFun fun, bool matchIndexSets) |
| template DoubleCRT & | DoubleCRT::Op< DoubleCRT::MulFun > (const NTL::ZZ &num, MulFun fun) |
| template DoubleCRT & | DoubleCRT::Op< DoubleCRT::AddFun > (const NTL::ZZ &num, AddFun fun) |
| template DoubleCRT & | DoubleCRT::Op< DoubleCRT::SubFun > (const NTL::ZZ &num, SubFun fun) |
| template DoubleCRT & | DoubleCRT::Op< DoubleCRT::MulFun > (const NTL::ZZX &poly, MulFun fun) |
| template DoubleCRT & | DoubleCRT::Op< DoubleCRT::AddFun > (const NTL::ZZX &poly, AddFun fun) |
| template DoubleCRT & | DoubleCRT::Op< DoubleCRT::SubFun > (const NTL::ZZX &poly, SubFun fun) |
| std::ostream & | operator<< (std::ostream &str, const DoubleCRT &d) |
| std::istream & | operator>> (std::istream &str, DoubleCRT &d) |
| void | totalSums (const EncryptedArray &ea, Ctxt &ctxt) |
| void | applyLinPoly1 (const EncryptedArray &ea, Ctxt &ctxt, const std::vector< NTL::ZZX > &C) |
| void | applyLinPolyMany (const EncryptedArray &ea, Ctxt &ctxt, const std::vector< std::vector< NTL::ZZX >> &Cvec) |
| template<typename P > | |
| void | applyLinPolyLL (Ctxt &ctxt, const std::vector< P > &encodedC, long d) |
| template void | applyLinPolyLL (Ctxt &ctxt, const std::vector< zzX > &encodedC, long d) |
| template void | applyLinPolyLL (Ctxt &ctxt, const std::vector< NTL::ZZX > &encodedC, long d) |
| template void | applyLinPolyLL (Ctxt &ctxt, const std::vector< DoubleCRT > &encodedC, long d) |
| void | print (const EncryptedArray &ea, std::ostream &s, const PlaintextArray &pa) |
| void | mapTo01 (const EncryptedArray &ea, Ctxt &ctxt) |
| template<typename Scheme > | |
| void | mapTo01 (const EncryptedArray &, Ptxt< Scheme > &ptxt) |
| template void | mapTo01 (const EncryptedArray &, Ptxt< BGV > &ptxt) |
| template void | mapTo01 (const EncryptedArray &, Ptxt< CKKS > &ptxt) |
| void | fastPower (Ctxt &ctxt, long d) |
| void | incrementalZeroTest (Ctxt *res[], const EncryptedArray &ea, const Ctxt &ctxt, long n) |
| void | RelaxedInv (NTL::Mat< NTL::zz_p > &x, const NTL::Mat< NTL::zz_p > &a) |
| void | RelaxedInv (NTL::Mat< NTL::GF2 > &x, const NTL::Mat< NTL::GF2 > &a) |
| void | TraceMap (NTL::GF2X &w, const NTL::GF2X &a, long d, const NTL::GF2XModulus &F, const NTL::GF2X &b) |
| template void | getHyperColumn (NTL::Vec< long > &v, const ConstCubeSlice< long > &s, long pos) |
| template void | setHyperColumn (const NTL::Vec< long > &v, const CubeSlice< long > &s, long pos) |
| template void | setHyperColumn (const NTL::Vec< long > &v, const CubeSlice< long > &s, long pos, const long &val) |
| template void | print3D (const HyperCube< long > &c) |
| template void | getHyperColumn (NTL::Vec< NTL::zz_p > &v, const ConstCubeSlice< NTL::zz_p > &s, long pos) |
| template void | setHyperColumn (const NTL::Vec< NTL::zz_p > &v, const CubeSlice< NTL::zz_p > &s, long pos) |
| template void | setHyperColumn (const NTL::Vec< NTL::zz_p > &v, const CubeSlice< NTL::zz_p > &s, long pos, const NTL::zz_p &val) |
| template void | print3D (const HyperCube< NTL::zz_p > &c) |
| std::ostream & | operator<< (std::ostream &str, const PubKey &pk) |
| std::istream & | operator>> (std::istream &str, PubKey &pk) |
| std::ostream & | operator<< (std::ostream &str, const SecKey &sk) |
| std::istream & | operator>> (std::istream &str, SecKey &sk) |
| void | printFlow (FlowGraph &fg) |
| std::shared_ptr< GeneralAutomorphPrecon > | buildGeneralAutomorphPrecon (const Ctxt &ctxt, long dim, const EncryptedArray &ea) |
| template<typename RX > | |
| std::shared_ptr< ConstMultiplier > | build_ConstMultiplier (const RX &poly) |
| template<typename RX , typename type > | |
| std::shared_ptr< ConstMultiplier > | build_ConstMultiplier (const RX &poly, long dim, long amt, const EncryptedArrayDerived< type > &ea) |
| void | MulAdd (Ctxt &x, const std::shared_ptr< ConstMultiplier > &a, const Ctxt &b) |
| void | DestMulAdd (Ctxt &x, const std::shared_ptr< ConstMultiplier > &a, Ctxt &b) |
| void | plaintextAutomorph_CKKS (zzX &b, const zzX &a, long j, const EncryptedArrayCx &ea) |
| void | GenBabySteps (std::vector< std::shared_ptr< Ctxt >> &v, const Ctxt &ctxt, long dim, bool clean) |
| template<typename zp , typename zz > | |
| void | FindPrimRootT (zp &root, unsigned long e) |
| template bool | intVecCRT (NTL::vec_ZZ &, const NTL::ZZ &, const NTL::vec_ZZ &, long) |
| template bool | intVecCRT (NTL::vec_ZZ &, const NTL::ZZ &, const NTL::vec_long &, long) |
| template bool | intVecCRT (NTL::vec_ZZ &, const NTL::ZZ &, const NTL::Vec< NTL::zz_p > &, long) |
| void | removeDups (std::list< long > &x, bool *aux) |
| void | addOffset (std::list< long > &x, long offset, long n, bool *aux, UNUSED bool good=false) |
| long | reducedCount (const std::list< long > &x, long n, bool *aux) |
| void | buildBenesCostTable (long n, long k, bool good, NTL::Vec< NTL::Vec< long >> &tab) |
| std::ostream & | operator<< (std::ostream &s, LongNodePtr p) |
| BenesMemoEntry | optimalBenesAux (long i, long budget, long nlev, const NTL::Vec< NTL::Vec< long >> &costTab, BenesMemoTable &memoTab) |
| void | optimalBenes (long n, long budget, bool good, long &cost, LongNodePtr &solution) |
| void | print (std::ostream &s, SplitNodePtr p, bool first) |
| std::ostream & | operator<< (std::ostream &s, SplitNodePtr p) |
| long | length (GenNodePtr ptr) |
| std::ostream & | operator<< (std::ostream &s, GenNodePtr p) |
| LowerMemoEntry | optimalLower (long order, bool good, long budget, long mid, LowerMemoTable &lowerMemoTable) |
| UpperMemoEntry | optimalUpperAux (const NTL::Vec< GenDescriptor > &vec, long i, long budget, long mid, UpperMemoTable &upperMemoTable, LowerMemoTable &lowerMemoTable) |
| template<typename RX > | |
| bool | poly_comp (const RX &a, const RX &b) |
| bool | less_than (NTL::GF2 a, NTL::GF2 b) |
| bool | less_than (NTL::zz_p a, NTL::zz_p b) |
| bool | less_than (const NTL::GF2X &a, const NTL::GF2X &b) |
| bool | less_than (const NTL::zz_pX &a, const NTL::zz_pX &b) |
| bool | less_than (const NTL::GF2E &a, const NTL::GF2E &b) |
| bool | less_than (const NTL::zz_pE &a, const NTL::zz_pE &b) |
| bool | less_than (const NTL::GF2EX &a, const NTL::GF2EX &b) |
| bool | less_than (const NTL::zz_pEX &a, const NTL::zz_pEX &b) |
| bool | comparePAlgebra (const PAlgebra &palg, unsigned long m, unsigned long p, UNUSED unsigned long r, const std::vector< long > &gens, const std::vector< long > &ords) |
| template<typename T > | |
| void | PAlgebraLift (const NTL::ZZX &phimx, const T &lfactors, T &factors, T &crtc, long r) |
| void | EDF (NTL::vec_zz_pX &v, const NTL::zz_pX &f, long d) |
| NTL::zz_pEX | FrobeniusMap (const NTL::zz_pEXModulus &F) |
| void | InvModpr (NTL::zz_pX &S, const NTL::zz_pX &F, const NTL::zz_pX &G, long p, long r) |
| template<> | |
| void | PAlgebraLift (const NTL::ZZX &phimx, const NTL::vec_zz_pX &lfactors, NTL::vec_zz_pX &factors, NTL::vec_zz_pX &crtc, long r) |
| std::ostream & | operator<< (std::ostream &s, const PermNetwork &net) |
| template void | applyPermToVec< long > (NTL::Vec< long > &out, const NTL::Vec< long > &in, const Permut &p1) |
| template void | applyPermToVec< long > (std::vector< long > &out, const std::vector< long > &in, const Permut &p1) |
| template void | applyPermToVec< NTL::ZZX > (std::vector< NTL::ZZX > &out, const std::vector< NTL::ZZX > &in, const Permut &p1) |
| template void | applyPermsToVec< long > (NTL::Vec< long > &out, const NTL::Vec< long > &in, const Permut &p2, const Permut &p1) |
| template void | applyPermsToVec< long > (std::vector< long > &out, const std::vector< long > &in, const Permut &p2, const Permut &p1) |
| void | breakPermTo3 (const HyperCube< long > &pi, long dim, ColPerm &rho1, HyperCube< long > &rho2, ColPerm &rho3) |
| void | ComputeOneGenMapping (Permut &genMap, const OneGeneratorTree &T) |
| to a single generator tree More... | |
| std::ostream & | operator<< (std::ostream &s, const SubDimension &sd) |
| std::ostream & | operator<< (std::ostream &s, const GeneratorTrees &trees) |
| void | deserialize (std::istream &is, PolyMod &poly) |
| void | serialize (std::ostream &os, const PolyMod &poly) |
| std::istream & | operator>> (std::istream &is, PolyMod &poly) |
| std::ostream & | operator<< (std::ostream &os, const PolyMod &poly) |
| std::ostream & | operator<< (std::ostream &os, const PolyModRing &ring) |
| void | computeDivVec (NTL::Vec< long > &divVec, long m, const NTL::Vec< long > &powVec) |
| void | computeInvVec (NTL::Vec< long > &invVec, const NTL::Vec< long > &divVec, const NTL::Vec< long > &powVec) |
| bool | operator> (const ModuliSizes::Entry &a, const ModuliSizes::Entry &b) |
| std::ostream & | operator<< (std::ostream &s, const ModuliSizes &szs) |
| std::istream & | operator>> (std::istream &s, ModuliSizes &szs) |
| template<typename Scheme > | |
| Scheme::SlotType | randomSlot (const Context &context) |
| template<> | |
| BGV::SlotType | randomSlot< BGV > (const Context &context) |
| template<> | |
| CKKS::SlotType | randomSlot< CKKS > (UNUSED const Context &context) |
| template void | deserialize< BGV > (std::istream &is, Ptxt< BGV > &ptxt) |
| template void | deserialize< CKKS > (std::istream &is, Ptxt< CKKS > &ptxt) |
| template void | serialize< BGV > (std::ostream &os, const Ptxt< BGV > &ptxt) |
| template void | serialize< CKKS > (std::ostream &os, const Ptxt< CKKS > &ptxt) |
| template std::istream & | operator>><BGV > (std::istream &is, Ptxt< BGV > &ptxt) |
| template std::istream & | operator>><CKKS > (std::istream &is, Ptxt< CKKS > &ptxt) |
| template std::ostream & | operator<<<BGV > (std::ostream &os, const Ptxt< BGV > &ptxt) |
| template std::ostream & | operator<<<CKKS > (std::ostream &os, const Ptxt< CKKS > &ptxt) |
| void | extractDigitsPacked (Ctxt &ctxt, long botHigh, long r, long ePrime, const std::vector< NTL::ZZX > &unpackSlotEncoding) |
| void | extractDigitsThin (Ctxt &ctxt, long botHigh, long r, long ePrime) |
| double | boundRoundingNoise (UNUSED long m, long phim, long p2r, double epsilon) |
| bool | timer_compare (const FHEtimer *a, const FHEtimer *b) |
Variables | |
| Context * | activeContext = nullptr |
| SecKey * | dbgKey = nullptr |
| std::shared_ptr< const EncryptedArray > | dbgEa = nullptr |
| NTL::ZZX | dbg_ptxt |
| bool | fhe_stats = false |
| Logger | helog |
| Internal global logger. More... | |
| int | fhe_test_force_bsgs = 0 |
| int | fhe_test_force_hoist = 0 |
| const long double | PI |
| const double | erfc_inverse [] |
| long | thinRecrypt_initial_level |
| long | fhe_force_chen_han = 0 |
| long | printFlag |
| NTL_THREAD_LOCAL bool | replicateVerboseFlag = false |
| int | fhe_watcher = 0 |
| const unsigned long | CLOCK_SCALE = (unsigned long)CLOCKS_PER_SEC |
Strategies for generating key-switching matrices | |
| long | KSGiantStepSize (long D) |
| Function that returns number of baby steps. Used to keep this and matmul routines "in sync". More... | |
| void | addAllMatrices (SecKey &sKey, long keyID=0) |
| Maximalistic approach: generate matrices s(X^e)->s(X) for all e in Zm*. More... | |
| void | addFewMatrices (SecKey &sKey, long keyID=0) |
| Generate matrices so every s(X^e) can be reLinearized in at most two steps. More... | |
| void | addSome1DMatrices (SecKey &sKey, long bound=HELIB_KEYSWITCH_THRESH, long keyID=0) |
| Generate some matrices of the form s(X^{g^i})->s(X), but not all. For a generator g whose order is larger than bound, generate only enough matrices for the giant-step/baby-step procedures (2*sqrt(ord(g))of them). More... | |
| void | add1DMatrices (SecKey &sKey, long keyID=0) |
| Generate all matrices s(X^{g^i})->s(X) for generators g of Zm* /(p) and i<ord(g). If g has different orders in Zm* and Zm* /(p) then generate also matrices of the form s(X^{g^{-i}})->s(X) More... | |
| void | addBSGS1DMatrices (SecKey &sKey, long keyID=0) |
| void | addSomeFrbMatrices (SecKey &sKey, long bound=HELIB_KEYSWITCH_THRESH, long keyID=0) |
| Generate all/some Frobenius matrices of the form s(X^{p^i})->s(X) More... | |
| void | addFrbMatrices (SecKey &sKey, long keyID=0) |
| void | addBSGSFrbMatrices (SecKey &sKey, long keyID=0) |
| void | addMinimal1DMatrices (SecKey &sKey, long keyID=0) |
| These routines just add a single matrix (or two, for bad dimensions) More... | |
| void | addMinimalFrbMatrices (SecKey &sKey, long keyID=0) |
| void | addMatrices4Network (SecKey &sKey, const PermNetwork &net, long keyID=0) |
| void | addTheseMatrices (SecKey &sKey, const std::set< long > &automVals, long keyID=0) |
| Generate specific key-switching matrices, described by the given set. More... | |
| void | PolyRed (NTL::ZZX &out, const NTL::ZZX &in, long q, bool abs=false) |
| Reduce all the coefficients of a polynomial modulo q. More... | |
| void | PolyRed (NTL::ZZX &out, const NTL::ZZX &in, const NTL::ZZ &q, bool abs=false) |
| void | PolyRed (NTL::ZZX &F, long q, bool abs=false) |
| void | PolyRed (NTL::ZZX &F, const NTL::ZZ &q, bool abs=false) |
| void | vecRed (NTL::Vec< NTL::ZZ > &out, const NTL::Vec< NTL::ZZ > &in, long q, bool abs) |
| void | vecRed (NTL::Vec< NTL::ZZ > &out, const NTL::Vec< NTL::ZZ > &in, const NTL::ZZ &q, bool abs) |
Some enhanced conversion routines | |
| void | convert (long &x1, const NTL::GF2X &x2) |
| void | convert (long &x1, const NTL::zz_pX &x2) |
| void | convert (NTL::vec_zz_pE &X, const std::vector< NTL::ZZX > &A) |
| void | convert (NTL::mat_zz_pE &X, const std::vector< std::vector< NTL::ZZX >> &A) |
| void | convert (std::vector< NTL::ZZX > &X, const NTL::vec_zz_pE &A) |
| void | convert (std::vector< std::vector< NTL::ZZX >> &X, const NTL::mat_zz_pE &A) |
| void | convert (NTL::Vec< long > &out, const NTL::ZZX &in) |
| void | convert (NTL::Vec< long > &out, const NTL::zz_pX &in, bool symmetric=true) |
| void | convert (NTL::Vec< long > &out, const NTL::GF2X &in) |
| void | convert (NTL::ZZX &out, const NTL::Vec< long > &in) |
| void | convert (NTL::GF2X &out, const NTL::Vec< long > &in) |
| double | boundFreshNoise (long m, long phim, double sigma, double epsilon=9e-13) |
| double | boundRoundingNoise (long m, long phim, long p2r, double epsilon=9e-13) |
Typedef Documentation
◆ aligned_vector
template<class T >
| using helib::aligned_vector = typedef PGFFT::aligned_vector<T> |
◆ cmplx_t
| typedef complex<double> helib::cmplx_t |
◆ CtPtrMat
| typedef PtrMatrix<Ctxt> helib::CtPtrMat |
◆ CtPtrMat_ptVecCt
| typedef PtrMatrix_ptVec<Ctxt> helib::CtPtrMat_ptVecCt |
◆ CtPtrMat_ptvectorCt
◆ CtPtrMat_VecCt
| typedef PtrMatrix_Vec<Ctxt> helib::CtPtrMat_VecCt |
◆ CtPtrMat_vectorCt
| typedef PtrMatrix_vector<Ctxt> helib::CtPtrMat_vectorCt |
◆ CtPtrs
| typedef PtrVector<Ctxt> helib::CtPtrs |
◆ CtPtrs_slice
| typedef PtrVector_slice<Ctxt> helib::CtPtrs_slice |
◆ CtPtrs_VecCt
| typedef PtrVector_VecT<Ctxt> helib::CtPtrs_VecCt |
◆ CtPtrs_VecPt
| typedef PtrVector_VecPt<Ctxt> helib::CtPtrs_VecPt |
◆ CtPtrs_vectorCt
| typedef PtrVector_vectorT<Ctxt> helib::CtPtrs_vectorCt |
◆ CtPtrs_vectorPt
| typedef PtrVector_vectorPt<Ctxt> helib::CtPtrs_vectorPt |
◆ cx_double
| typedef std::complex< double > helib::cx_double |
◆ DCRTptr
| typedef std::shared_ptr<DoubleCRT> helib::DCRTptr |
◆ FlowGraph
| typedef std::vector<FNeighborList> helib::FlowGraph |
◆ FNeighborList
| typedef std::unordered_map<long, FlowEdge> helib::FNeighborList |
◆ ldbl
| typedef long double helib::ldbl |
◆ LNeighborList
| typedef std::unordered_multimap<long, LabeledEdge> helib::LNeighborList |
◆ LONG
| typedef long helib::LONG |
◆ Matrix
template<typename T >
| using helib::Matrix = typedef Tensor<T, 2> |
◆ NodeIdx
| typedef std::pair<long, long> helib::NodeIdx |
◆ OneGeneratorTree
◆ Permut
| typedef NTL::Vec<long> helib::Permut |
A simple permutation is just a vector with p[i]=\pi_i.
◆ QueryExpr
| using helib::QueryExpr = typedef std::shared_ptr<Expr> |
An alias for a shared pointer to an Expr object.
◆ Vector
template<typename T >
| using helib::Vector = typedef Tensor<T, 1> |
◆ zzX
| typedef NTL::Vec<long> helib::zzX |
◆ ZZXptr
| typedef std::shared_ptr<NTL::ZZX> helib::ZZXptr |
Enumeration Type Documentation
◆ PA_tag
| enum helib::PA_tag |
Function Documentation
◆ add() [1/3]
| void helib::add | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| const PlaintextArray & | other | ||
| ) |
◆ add() [2/3]
| void helib::add | ( | std::vector< NTL::ZZX > & | x, |
| const std::vector< NTL::ZZX > & | a, | ||
| const std::vector< NTL::ZZX > & | b | ||
| ) |
◆ add() [3/3]
◆ add1DMatrices()
| void helib::add1DMatrices | ( | SecKey & | sKey, |
| long | keyID = 0 |
||
| ) |
Generate all matrices s(X^{g^i})->s(X) for generators g of Zm* /(p) and i<ord(g). If g has different orders in Zm* and Zm* /(p) then generate also matrices of the form s(X^{g^{-i}})->s(X)
◆ addAllMatrices()
| void helib::addAllMatrices | ( | SecKey & | sKey, |
| long | keyID = 0 |
||
| ) |
Maximalistic approach: generate matrices s(X^e)->s(X) for all e in Zm*.
◆ addBSGS1DMatrices()
| void helib::addBSGS1DMatrices | ( | SecKey & | sKey, |
| long | keyID = 0 |
||
| ) |
◆ addBSGSFrbMatrices()
| void helib::addBSGSFrbMatrices | ( | SecKey & | sKey, |
| long | keyID = 0 |
||
| ) |
◆ addFewMatrices()
| void helib::addFewMatrices | ( | SecKey & | sKey, |
| long | keyID = 0 |
||
| ) |
Generate matrices so every s(X^e) can be reLinearized in at most two steps.
◆ addFrbMatrices()
| void helib::addFrbMatrices | ( | SecKey & | sKey, |
| long | keyID = 0 |
||
| ) |
◆ addManyNumbers()
| void helib::addManyNumbers | ( | CtPtrs & | sum, |
| CtPtrMat & | numbers, | ||
| long | sizeLimit = 0, |
||
| std::vector< zzX > * | unpackSlotEncoding = nullptr |
||
| ) |
Sum an arbitrary amount of numbers in binary representation.
- Parameters
-
sum result of the summation. numbers values of which to sum. sizeLimit number of bits to compute on, taken from the least significant end. unpackSlotEncoding vector of constants for unpacking, as used in bootstrapping.
Calculates the sum of many numbers using the 3-for-2 method.
◆ addMatrices4Network()
| void helib::addMatrices4Network | ( | SecKey & | sKey, |
| const PermNetwork & | net, | ||
| long | keyID = 0 |
||
| ) |
◆ addMinimal1DMatrices()
| void helib::addMinimal1DMatrices | ( | SecKey & | sKey, |
| long | keyID = 0 |
||
| ) |
These routines just add a single matrix (or two, for bad dimensions)
◆ addMinimalFrbMatrices()
| void helib::addMinimalFrbMatrices | ( | SecKey & | sKey, |
| long | keyID = 0 |
||
| ) |
◆ addOffset()
| void helib::addOffset | ( | std::list< long > & | x, |
| long | offset, | ||
| long | n, | ||
| bool * | aux, | ||
| UNUSED bool | good = false |
||
| ) |
◆ addSome1DMatrices()
| void helib::addSome1DMatrices | ( | SecKey & | sKey, |
| long | bound = HELIB_KEYSWITCH_THRESH, |
||
| long | keyID = 0 |
||
| ) |
Generate some matrices of the form s(X^{g^i})->s(X), but not all. For a generator g whose order is larger than bound, generate only enough matrices for the giant-step/baby-step procedures (2*sqrt(ord(g))of them).
◆ addSomeFrbMatrices()
| void helib::addSomeFrbMatrices | ( | SecKey & | sKey, |
| long | bound = HELIB_KEYSWITCH_THRESH, |
||
| long | keyID = 0 |
||
| ) |
Generate all/some Frobenius matrices of the form s(X^{p^i})->s(X)
◆ addSomePrimes()
| void helib::addSomePrimes | ( | Ctxt & | c | ) |
◆ addTheseMatrices()
| void helib::addTheseMatrices | ( | SecKey & | sKey, |
| const std::set< long > & | automVals, | ||
| long | keyID = 0 |
||
| ) |
Generate specific key-switching matrices, described by the given set.
◆ addTwoNumbers()
| void helib::addTwoNumbers | ( | CtPtrs & | sum, |
| const CtPtrs & | lhs, | ||
| const CtPtrs & | rhs, | ||
| long | sizeLimit = 0, |
||
| std::vector< zzX > * | unpackSlotEncoding = nullptr |
||
| ) |
Adds two numbers in binary representation where each ciphertext of the input vector contains a bit.
Add two integers in binary representation.
- Parameters
-
sum result of the addition operation. lhs left hand side of the addition. rhs right hand side of the addition. sizeLimit number of bits to compute on, taken from the least significant end. unpackSlotEncoding vector of constants for unpacking, as used in bootstrapping.
◆ applyLinPoly() [1/2]
| void helib::applyLinPoly | ( | NTL::GF2E & | beta, |
| const NTL::vec_GF2E & | C, | ||
| const NTL::GF2E & | alpha, | ||
| long | p | ||
| ) |
A version for GF2: must be called with p == 2 and r == 1.
◆ applyLinPoly() [2/2]
| void helib::applyLinPoly | ( | NTL::zz_pE & | beta, |
| const NTL::vec_zz_pE & | C, | ||
| const NTL::zz_pE & | alpha, | ||
| long | p | ||
| ) |
Apply a linearized polynomial with coefficient vector C.
NTL's current smallint modulus, zz_p::modulus(), is assumed to be p^r, for p prime, r >= 1 integer.
◆ applyLinPoly1()
| void helib::applyLinPoly1 | ( | const EncryptedArray & | ea, |
| Ctxt & | ctxt, | ||
| const std::vector< NTL::ZZX > & | C | ||
| ) |
◆ applyLinPolyLL() [1/4]
| template void helib::applyLinPolyLL | ( | Ctxt & | ctxt, |
| const std::vector< DoubleCRT > & | encodedC, | ||
| long | d | ||
| ) |
◆ applyLinPolyLL() [2/4]
| template void helib::applyLinPolyLL | ( | Ctxt & | ctxt, |
| const std::vector< NTL::ZZX > & | encodedC, | ||
| long | d | ||
| ) |
◆ applyLinPolyLL() [3/4]
template<typename P >
| void helib::applyLinPolyLL | ( | Ctxt & | ctxt, |
| const std::vector< P > & | encodedC, | ||
| long | d | ||
| ) |
◆ applyLinPolyLL() [4/4]
◆ applyLinPolyMany()
| void helib::applyLinPolyMany | ( | const EncryptedArray & | ea, |
| Ctxt & | ctxt, | ||
| const std::vector< std::vector< NTL::ZZX >> & | Cvec | ||
| ) |
◆ applyPerm()
| void helib::applyPerm | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| const NTL::Vec< long > & | pi | ||
| ) |
◆ applyPermsToVec() [1/2]
template<typename T >
| void helib::applyPermsToVec | ( | NTL::Vec< T > & | out, |
| const NTL::Vec< T > & | in, | ||
| const Permut & | p2, | ||
| const Permut & | p1 | ||
| ) |
Apply two permutations to a std::vector out[i]=in[p2[p1[i]]] (NOT in-place)
◆ applyPermsToVec() [2/2]
template<typename T >
| void helib::applyPermsToVec | ( | std::vector< T > & | out, |
| const std::vector< T > & | in, | ||
| const Permut & | p2, | ||
| const Permut & | p1 | ||
| ) |
◆ applyPermsToVec< long >() [1/2]
| template void helib::applyPermsToVec< long > | ( | NTL::Vec< long > & | out, |
| const NTL::Vec< long > & | in, | ||
| const Permut & | p2, | ||
| const Permut & | p1 | ||
| ) |
◆ applyPermsToVec< long >() [2/2]
| template void helib::applyPermsToVec< long > | ( | std::vector< long > & | out, |
| const std::vector< long > & | in, | ||
| const Permut & | p2, | ||
| const Permut & | p1 | ||
| ) |
◆ applyPermToVec() [1/2]
template<typename T >
| void helib::applyPermToVec | ( | NTL::Vec< T > & | out, |
| const NTL::Vec< T > & | in, | ||
| const Permut & | p1 | ||
| ) |
Apply a permutation to a std::vector, out[i]=in[p1[i]] (NOT in-place)
◆ applyPermToVec() [2/2]
template<typename T >
| void helib::applyPermToVec | ( | std::vector< T > & | out, |
| const std::vector< T > & | in, | ||
| const Permut & | p1 | ||
| ) |
◆ applyPermToVec< long >() [1/2]
| template void helib::applyPermToVec< long > | ( | NTL::Vec< long > & | out, |
| const NTL::Vec< long > & | in, | ||
| const Permut & | p1 | ||
| ) |
◆ applyPermToVec< long >() [2/2]
| template void helib::applyPermToVec< long > | ( | std::vector< long > & | out, |
| const std::vector< long > & | in, | ||
| const Permut & | p1 | ||
| ) |
◆ applyPermToVec< NTL::ZZX >()
| template void helib::applyPermToVec< NTL::ZZX > | ( | std::vector< NTL::ZZX > & | out, |
| const std::vector< NTL::ZZX > & | in, | ||
| const Permut & | p1 | ||
| ) |
◆ areTimersOn()
|
inline |
◆ argmax() [1/2]
|
inline |
A variant with a specialized comparison function (*moreThan)(a,b) returns the comparison a>b.
◆ argmax() [2/2]
template<typename T >
| long helib::argmax | ( | std::vector< T > & | v | ) |
◆ argmin()
template<typename T >
| long helib::argmin | ( | std::vector< T > & | v | ) |
◆ argminmax()
template<typename T , bool maxFlag>
| long helib::argminmax | ( | std::vector< T > & | v | ) |
Find the index of the (first) largest/smallest element.
These procedures are roughly just simpler variants of std::max_element and std::min_element. argmin/argmax are implemented as a template, so the code must be placed in the header file for the compiler to find it. The class T must have an implementation of operator> and operator< for this template to work.
- Template Parameters
-
maxFlag A boolean value: true - argmax, false - argmin
◆ assertEq()
template<typename ExceptionTy = ::helib::LogicError, typename T = void>
|
inline |
Function throwing an exception of type ExceptionTy if the two arguments are not equal.
- Template Parameters
-
ExceptionTy type of the exception thrown. T type of the elements to be compared.
- Parameters
-
a the first element to be compared. b the second element to be compared. message the message of the exception raised if the two values are not equal.
- Exceptions
-
ExceptionTy exception if the two values are not equal.
- Note
- ExceptionTy first and T defaulted to void so that one can specify only ExceptionTy, letting T be inferred from the argument passed.
◆ assertFalse()
template<typename ExceptionTy = ::helib::LogicError, typename T = void>
|
inline |
Function throwing an exception of type ExceptionTy if the condition is true.
- Template Parameters
-
ExceptionTy type of the exception thrown. T type of the condition being checked (must be a bool).
- Parameters
-
value the condition being checked. message the message of the exception raised if the condition is true.
- Exceptions
-
ExceptionTy exception if condition is true.
- Note
- ExceptionTy first and T defaulted to void so that one can specify only ExceptionTy, letting T be inferred from the argument passed.
◆ assertInRange()
template<typename ExceptionTy = ::helib::OutOfRangeError, typename T = void>
|
inline |
Function throwing an exception of type ExceptionTy if the element is in the range [min,max) or [min, max]
- Template Parameters
-
ExceptionTy type of the exception thrown. T type of the element (and of the range).
- Parameters
-
elem the element to be tested. min the left side of the range (always inclusive). max the right side of the range (default exclusive). message the message of the exception raised if the element is not in the range. right_inclusive flag specifying if the right side is inclusive (default false).
- Exceptions
-
ExceptionTy exception if elem is not in the range
- Note
- ExceptionTy first and T defaulted to void so that one can specify only ExceptionTy, letting T be inferred from the argument passed.
◆ assertNeq()
template<typename ExceptionTy = ::helib::LogicError, typename T = void>
|
inline |
Function throwing an exception of type ExceptionTy if the two arguments are equal.
- Template Parameters
-
ExceptionTy type of the exception thrown. T type of the elements to be compared.
- Parameters
-
a the first element to be compared. b the second element to be compared. message the message of the exception raised if the two values are equal.
- Exceptions
-
ExceptionTy exception if the two values are equal.
- Note
- ExceptionTy first and T defaulted to void so that one can specify only ExceptionTy, letting T be inferred from the argument passed.
◆ assertNotNull()
template<typename ExceptionTy = ::helib::LogicError, typename T = void>
|
inline |
Function throwing an exception of type ExceptionTy if the argument is nullptr.
- Template Parameters
-
ExceptionTy type of the exception thrown. T type of the element.
- Parameters
-
p the element to be tested. message the message of the exception raised if the element is nullptr.
- Exceptions
-
ExceptionTy exception if p is nullptr.
- Note
- ExceptionTy first and T defaulted to void so that one can specify only ExceptionTy, letting T be inferred from the argument passed.
◆ assertTrue()
template<typename ExceptionTy = ::helib::LogicError, typename T = void>
|
inline |
Function throwing an exception of type ExceptionTy if the condition is false.
- Template Parameters
-
ExceptionTy type of the exception thrown. T type of the condition being checked (must be a bool).
- Parameters
-
value the condition being checked. message the message of the exception raised if the condition is false.
- Exceptions
-
ExceptionTy exception if condition is false.
- Note
- ExceptionTy first and T defaulted to void so that one can specify only ExceptionTy, letting T be inferred from the argument passed.
◆ atoVec()
template<typename T >
| NTL::Vec<T> helib::atoVec | ( | const char * | a | ) |
◆ atovector()
template<typename T >
| std::vector<T> helib::atovector | ( | const char * | a | ) |
◆ balanced_MulMod()
| void helib::balanced_MulMod | ( | NTL::ZZX & | out, |
| const NTL::ZZX & | f, | ||
| long | a, | ||
| long | q | ||
| ) |
Multiply the polynomial f by the integer a modulo q output coefficients are balanced (appropriately randomized for even q)
◆ balanced_zzX() [1/2]
| zzX helib::balanced_zzX | ( | const NTL::GF2X & | f | ) |
◆ balanced_zzX() [2/2]
| zzX helib::balanced_zzX | ( | const NTL::zz_pX & | f | ) |
◆ balRem()
|
inline |
Return balanced remainder. Assumes a in [0, q) and returns balanced remainder in (-q/2, q/2]
◆ binaryCond()
| void helib::binaryCond | ( | CtPtrs & | output, |
| const Ctxt & | cond, | ||
| const CtPtrs & | trueValue, | ||
| const CtPtrs & | falseValue | ||
| ) |
Implementation of output = cond * trueValue + (1 - cond) * falseValue.
Implementation of output = cond ? trueValue : falseValue.
- Parameters
-
output Equal to trueValuein slots wherecondis one andfalseValuein slots wherecondis zero.cond The condition, namely a Ctxtcontaining elements of {0,1} in each slot.trueValue Value of outputwherevercondis one.falseValue Value of outputwherevercondis zero.
- Note
trueValue,falseValueandoutputmust have the same size.
◆ binaryMask()
Zeroes the slots of binaryNums where the corresponding slot of mask is 0.
Apply mask across the vector of bits slot-wise.
- Parameters
-
binaryNums Input bits on which to mask (this is done in place). mask Encrypted mask indicating desired slots.
◆ binSumReduction()
template<typename TXT >
|
inline |
Performs a binary summation of a vector of elements.
- Template Parameters
-
TXT type of the elements of which to sum.
- Parameters
-
ctxtArray The array on which to perform the binary sum.
- Note
- This function is destructive on the array.
◆ bitSetToLong()
| long helib::bitSetToLong | ( | long | bits, |
| long | bitSize | ||
| ) |
Considers bits as a vector of bits and returns the value it represents when interpreted as a n-bit 2's complement number, where n is given by bitSize.
- Parameters
-
bits The value containing the bits to be reinterpreted. bitSize The number of bits to use, taken from the least significant end of bits.
- Returns
- The value of the reinterpreted number as a long.
◆ bitwiseAnd() [1/2]
Compute a bitwise AND between input and a std::vector<long>.
Compute a bitwise AND between input and mask.
- Parameters
-
output Equal to the output of the AND operation. input Number to AND. mask Number to AND with input. This should be a vector of elements of {0,1}.
- Note
- The size of
outputandinputmust be the same.
◆ bitwiseAnd() [2/2]
Compute a bitwise AND between lhs and rhs.
- Parameters
-
output Result of bitwise lhsANDrhs.lhs Left operand to the AND operation. rhs Right operand to the AND operation.
- Note
output,lhsandrhsmust all have the same size.
◆ bitwiseNot()
Compute a bitwise NOT of input.
- Parameters
-
output Result of bit-flipping input.input Binary number to be bit-flipped.
- Note
- The size of
outputandinputmust be the same.
◆ bitwiseOr()
Compute a bitwise OR between lhs and rhs.
- Parameters
-
output Result of bitwise lhsORrhs.lhs Left operand to the OR operation. rhs Right operand to the OR operation.
- Note
output,lhsandrhsmust all have the same size.
◆ bitwiseRotate()
Rotate input by rotamt.
Rotate binary numbers by rotamt.
- Parameters
-
output Rotated result. input The number to be bitwise-rotated. rotamt The amount by which to rotate input. May be negative for opposite-direction rotations.
- Note
- For positive
rotamtarguments, this rotates towards the most-significant end (i.e. the same direction as leftBitwiseShift). -
The size of
outputandinputmust be the same.
◆ bitwiseXOR()
Compute a bitwise XOR between lhs and rhs.
- Parameters
-
output Result of bitwise lhsXORrhs.lhs Left operand to the XOR operation. rhs Right operand to the XOR operation.
- Note
output,lhsandrhsmust all have the same size.
◆ BluesteinFFT() [1/2]
| void helib::BluesteinFFT | ( | NTL::zz_pX & | x, |
| long | n, | ||
| const NTL::zz_p & | root, | ||
| const NTL::zz_pX & | powers, | ||
| const NTL::Vec< NTL::mulmod_precon_t > & | powers_aux, | ||
| const NTL::fftRep & | Rb | ||
| ) |
apply bluestein
◆ BluesteinFFT() [2/2]
| void helib::BluesteinFFT | ( | NTL::zz_pX & | x, |
| long | n, | ||
| UNUSED const NTL::zz_p & | root, | ||
| const NTL::zz_pX & | powers, | ||
| const NTL::Vec< NTL::mulmod_precon_t > & | powers_aux, | ||
| const NTL::fftRep & | Rb | ||
| ) |
◆ BluesteinInit()
| void helib::BluesteinInit | ( | long | n, |
| const NTL::zz_p & | root, | ||
| NTL::zz_pX & | powers, | ||
| NTL::Vec< NTL::mulmod_precon_t > & | powers_aux, | ||
| NTL::fftRep & | Rb | ||
| ) |
initialize bluestein
◆ boundFreshNoise()
| double helib::boundFreshNoise | ( | long | m, |
| long | phim, | ||
| double | sigma, | ||
| double | epsilon = 9e-13 |
||
| ) |
Helper functions, return a bound B such that for random noise terms we have Pr[|canonicalEmbed(noise)|_{\infty} > B] < epsilon. (The default is epsilon = 2^{-40}.)
◆ boundRoundingNoise() [1/2]
| double helib::boundRoundingNoise | ( | long | m, |
| long | phim, | ||
| long | p2r, | ||
| double | epsilon = 9e-13 |
||
| ) |
◆ boundRoundingNoise() [2/2]
| double helib::boundRoundingNoise | ( | UNUSED long | m, |
| long | phim, | ||
| long | p2r, | ||
| double | epsilon | ||
| ) |
◆ breakPermByDim()
| void helib::breakPermByDim | ( | std::vector< ColPerm > & | out, |
| const Permut & | pi, | ||
| const CubeSignature & | sig | ||
| ) |
Takes a permutation pi over m-dimensional cube C=Z_{n1} x...x Z_{nm} and expresses pi as a product pi = rho_{2m-1} o ... o rho_2 o rho_1 where each rho_i is a column permutation along one dimension. Specifically for i<m, the permutations rho_i and rho_{2(m-1)-i} permute the i'th dimension.
◆ breakPermTo3()
| void helib::breakPermTo3 | ( | const HyperCube< long > & | pi, |
| long | dim, | ||
| ColPerm & | rho1, | ||
| HyperCube< long > & | rho2, | ||
| ColPerm & | rho3 | ||
| ) |
◆ build_ConstMultiplier() [1/2]
template<typename RX >
| std::shared_ptr<ConstMultiplier> helib::build_ConstMultiplier | ( | const RX & | poly | ) |
◆ build_ConstMultiplier() [2/2]
template<typename RX , typename type >
| std::shared_ptr<ConstMultiplier> helib::build_ConstMultiplier | ( | const RX & | poly, |
| long | dim, | ||
| long | amt, | ||
| const EncryptedArrayDerived< type > & | ea | ||
| ) |
◆ buildBenesCostTable()
| void helib::buildBenesCostTable | ( | long | n, |
| long | k, | ||
| bool | good, | ||
| NTL::Vec< NTL::Vec< long >> & | tab | ||
| ) |
◆ BuildContext()
| NTL::zz_pContext helib::BuildContext | ( | long | p, |
| long | maxroot | ||
| ) |
◆ buildContextFromAscii()
| std::unique_ptr< Context > helib::buildContextFromAscii | ( | std::istream & | str | ) |
◆ buildContextFromBinary()
| std::unique_ptr< Context > helib::buildContextFromBinary | ( | std::istream & | str | ) |
◆ buildEncryptedArray()
| EncryptedArrayBase * helib::buildEncryptedArray | ( | const Context & | context, |
| const PAlgebraMod & | alMod, | ||
| const NTL::ZZX & | G = NTL::ZZX::zero() |
||
| ) |
A "factory" for building EncryptedArrays.
◆ buildGeneralAutomorphPrecon()
| std::shared_ptr<GeneralAutomorphPrecon> helib::buildGeneralAutomorphPrecon | ( | const Ctxt & | ctxt, |
| long | dim, | ||
| const EncryptedArray & | ea | ||
| ) |
◆ buildLinPolyCoeffs() [1/2]
| void helib::buildLinPolyCoeffs | ( | NTL::vec_GF2E & | C, |
| const NTL::vec_GF2E & | L, | ||
| long | p, | ||
| long | r | ||
| ) |
A version for GF2: must be called with p == 2 and r == 1.
◆ buildLinPolyCoeffs() [2/2]
| void helib::buildLinPolyCoeffs | ( | NTL::vec_zz_pE & | C, |
| const NTL::vec_zz_pE & | L, | ||
| long | p, | ||
| long | r | ||
| ) |
Combination of buildLinPolyMatrix and ppsolve.
Obtain the linearized polynomial coefficients from a vector L representing the action of a linear map on the standard basis for zz_pE over zz_p.
NTL's current smallint modulus, zz_p::modulus(), is assumed to be p^r, for p prime, r >= 1 integer.
◆ buildLinPolyMatrix() [1/2]
| void helib::buildLinPolyMatrix | ( | NTL::mat_GF2E & | M, |
| long | p | ||
| ) |
◆ buildLinPolyMatrix() [2/2]
| void helib::buildLinPolyMatrix | ( | NTL::mat_zz_pE & | M, |
| long | p | ||
| ) |
◆ buildLookupTable()
| void helib::buildLookupTable | ( | std::vector< zzX > & | T, |
| std::function< double(double)> | f, | ||
| long | nbits_in, | ||
| long | scale_in, | ||
| long | sign_in, | ||
| long | nbits_out, | ||
| long | scale_out, | ||
| long | sign_out, | ||
| const EncryptedArray & | ea | ||
| ) |
Built a table-lookup for a function in fixed-point representation.
@function buildLookupTable FIXED-POINT CONVENTIONS: Fixed-point numbers are specified by a triple (nbits,scale,signed). Such a number is represented as an integer x with nbits bits. If signed == 1, then x is treated as a signed integer in 2's compliment; otherwise it is as an unsigned integer. The value represented by x is x*2^{scale}.
The buildLookupTable function builds a lookup table T, which can be used in conjunction with the tableLookup function above. The size of T will be 2^{nbits_in}. For every signed integer x with bit-size 'nbits_in', we will have T[x] = f(x * 2^{scale_in}) * 2^{-scale_out}), rounded to the nearest integer and truncated to 'nbits_out' bits. The bits are packed inside the slots, so it is assumed that each slot has enough room to fit these many bits. (Otherwise we only keep as many low-order bits as fit in a slot.)
SATURATED ARITHMETIC: Applications of f that return a result that is too large to represent in the output format will be converted to the maximum representable value. Similarly, Applications of f that return a result that is too small will be converted to the minimal representable value. (This applies also to applications of f that return infinites, NaNs will just be mapped to zero.) For this to work correctly, you should be working with standard IEEE arithmetic...which will be the case on almost all platforms.
EXAMPLE:
buildLookupTable(T, [](double x){ return 1/x;}, nbits_in, scale_in, nbits_out, scale_out, sign_out, ea)
will build a lookup table for inversion.
◆ buildModChain()
| void helib::buildModChain | ( | Context & | context, |
| long | nBits, | ||
| long | nDgts = 3, |
||
| bool | willBeBootstrappable = false, |
||
| long | skHwt = 0, |
||
| long | resolution = 3, |
||
| long | bitsInSpecialPrimes = 0 |
||
| ) |
◆ buildPAlgebraMod()
| PAlgebraModBase * helib::buildPAlgebraMod | ( | const PAlgebra & | zMStar, |
| long | r | ||
| ) |
Builds a table, of type PA_GF2 if p == 2 and r == 1, and PA_zz_p otherwise.
◆ buildRandomBlockMatrix()
| BlockMatMul1D * helib::buildRandomBlockMatrix | ( | const EncryptedArray & | ea, |
| long | dim | ||
| ) |
◆ buildRandomFullBlockMatrix()
| BlockMatMulFull * helib::buildRandomFullBlockMatrix | ( | const EncryptedArray & | ea | ) |
◆ buildRandomFullMatrix()
| MatMulFull * helib::buildRandomFullMatrix | ( | const EncryptedArray & | ea | ) |
◆ buildRandomMatrix()
| MatMul1D * helib::buildRandomMatrix | ( | const EncryptedArray & | ea, |
| long | dim | ||
| ) |
◆ buildRandomMultiBlockMatrix()
| BlockMatMul1D * helib::buildRandomMultiBlockMatrix | ( | const EncryptedArray & | ea, |
| long | dim | ||
| ) |
◆ buildRandomMultiMatrix()
| MatMul1D * helib::buildRandomMultiMatrix | ( | const EncryptedArray & | ea, |
| long | dim | ||
| ) |
◆ buildUnpackSlotEncoding()
| void helib::buildUnpackSlotEncoding | ( | std::vector< zzX > & | unpackSlotEncoding, |
| const EncryptedArray & | ea | ||
| ) |
◆ calcPolyNormBnd()
| double helib::calcPolyNormBnd | ( | long | m | ) |
◆ calculateMasks() [1/2]
template<typename TXT >
| Matrix<Ctxt> helib::calculateMasks | ( | const EncryptedArray & | ea, |
| Matrix< TXT > | query, | ||
| const Matrix< Ctxt > & | database | ||
| ) |
Given a query set and a database, calculates a mask of {0,1} where 1 signifies a matching element and 0 otherwise.
- Parameters
-
ea The encrypted array object holding information about the scheme. query The query set to mask against the database. Must be a row vector of the same dimension as the second dimension of the database matrix. database The matrix holding the encrypted database.
- Returns
- The calculated mask. Is the same size as the database.
- Note
- This is an overloaded function for when the database is encrypted.
◆ calculateMasks() [2/2]
template<typename TXT >
|
inline |
Given a query set and a database, calculates a mask of {0,1} where 1 signifies a matching element and 0 otherwise.
- Parameters
-
ea The encrypted array object holding information about the scheme. query The query set to mask against the database. Must be a row vector of the same dimension as the second dimension of the database matrix. database The matrix holding the plaintext database.
- Returns
- The calculated mask. Is the same size as the database.
- Note
- This is an overloaded function for when the database is not encrypted.
◆ calculateScores()
template<typename TXT >
|
inline |
Given a mask and information about the query to be performed, calculates a score for each matching element signified by the mask.
- Parameters
-
index_sets The set of indicies signifying which columns of the mask to query. offsets The constant term to be added to the final score of each queried column. weights The weighted importance assigned to each queried column. mask The mask with which to calculate the score from.
◆ calculateSetIntersection()
template<typename TXT >
|
inline |
Given two sets, calculates and returns the set intersection.
- Parameters
-
query The query set of type TXTwhere the elements of the set are held in the slots.server_set The server set. A vector of integer polynomials.
- Returns
- A set of the same size as
queryholding the elements in the intersecting set.
◆ card()
| long helib::card | ( | const IndexSet & | s | ) |
Functional cardinality.
◆ CheckCtxt()
| void helib::CheckCtxt | ( | const Ctxt & | c, |
| const char * | label | ||
| ) |
print to cerr some info about ciphertext
◆ checkNoise()
| void helib::checkNoise | ( | const Ctxt & | ctxt, |
| const SecKey & | sk, | ||
| const std::string & | msg, | ||
| double | thresh = 10.0 |
||
| ) |
◆ CKKS_canonicalEmbedding() [1/3]
| void helib::CKKS_canonicalEmbedding | ( | std::vector< cx_double > & | v, |
| const NTL::ZZX & | f, | ||
| const PAlgebra & | palg | ||
| ) |
◆ CKKS_canonicalEmbedding() [2/3]
| void helib::CKKS_canonicalEmbedding | ( | std::vector< cx_double > & | v, |
| const std::vector< double > & | f, | ||
| const PAlgebra & | palg | ||
| ) |
◆ CKKS_canonicalEmbedding() [3/3]
| void helib::CKKS_canonicalEmbedding | ( | std::vector< cx_double > & | v, |
| const zzX & | f, | ||
| const PAlgebra & | palg | ||
| ) |
Computes canonical embedding. Requires p==-1 and m==2^k where k >=2 and f.length() < m/2. Sets v[m/4-1-i] = DFT[palg.ith_rep(i)] for i in range(m/4), where DFT[j] = f(W^j) for j in range(m), and W = exp(-2*pi*I/m).
◆ CKKS_embedInSlots()
| void helib::CKKS_embedInSlots | ( | zzX & | f, |
| const std::vector< cx_double > & | v, | ||
| const PAlgebra & | palg, | ||
| double | scaling | ||
| ) |
Requires p==-1 and m==2^k where k >=2. Computes the inverse of canonical embedding, scaled by scaling and then rounded to nearest integer.
◆ cleanupDebugGlobals()
|
inline |
Cleanup function for clearing the global debug variables.
◆ clear()
|
inline |
◆ closeToOne()
|
inline |
◆ coeffsL2Norm() [1/3]
|
inline |
◆ coeffsL2Norm() [2/3]
|
inline |
◆ coeffsL2Norm() [3/3]
|
inline |
◆ coeffsL2NormSquared() [1/3]
| NTL::xdouble helib::coeffsL2NormSquared | ( | const DoubleCRT & | f | ) |
◆ coeffsL2NormSquared() [2/3]
| NTL::xdouble helib::coeffsL2NormSquared | ( | const NTL::ZZX & | f | ) |
◆ coeffsL2NormSquared() [3/3]
| double helib::coeffsL2NormSquared | ( | const zzX & | f | ) |
The L2-norm of an element (in coefficient representation)
◆ comparePAlgebra() [1/2]
| bool helib::comparePAlgebra | ( | const PAlgebra & | palg, |
| unsigned long | m, | ||
| unsigned long | p, | ||
| unsigned long | r, | ||
| const std::vector< long > & | gens, | ||
| const std::vector< long > & | ords | ||
| ) |
returns true if the palg parameters match the rest, false otherwise
◆ comparePAlgebra() [2/2]
| bool helib::comparePAlgebra | ( | const PAlgebra & | palg, |
| unsigned long | m, | ||
| unsigned long | p, | ||
| UNUSED unsigned long | r, | ||
| const std::vector< long > & | gens, | ||
| const std::vector< long > & | ords | ||
| ) |
◆ compareTwoNumbers() [1/2]
| void helib::compareTwoNumbers | ( | CtPtrs & | max, |
| CtPtrs & | min, | ||
| Ctxt & | mu, | ||
| Ctxt & | ni, | ||
| const CtPtrs & | a, | ||
| const CtPtrs & | b, | ||
| bool | twosComplement = false, |
||
| std::vector< zzX > * | unpackSlotEncoding = nullptr |
||
| ) |
Compares two integers in binary a, b. Returns max(a, b), min(a, b) and indicator bits mu=(a>b) and ni=(a<b)
- Parameters
-
max Maximum of aandb.min Minimum of aandb.mu Indicator bits mu=(a>b).ni Indicator bits ni=(a<b).a First number to compare. b Second number to compare. twosComplement When set to true, the inputs are signed integers in 2's complement. If set tofalse(default), unsigned comparison is performed.unpackSlotEncoding Vector of constants for unpacking, as used in bootstrapping.
- Note
- If
a=bthenmu=ni=0
◆ compareTwoNumbers() [2/2]
| void helib::compareTwoNumbers | ( | Ctxt & | mu, |
| Ctxt & | ni, | ||
| const CtPtrs & | a, | ||
| const CtPtrs & | b, | ||
| bool | twosComplement = false, |
||
| std::vector< zzX > * | unpackSlotEncoding = nullptr |
||
| ) |
Compares two integers in binary a, b. Returns only indicator bits mu=(a>b) and ni=(a<b).
- Parameters
-
mu Indicator bits mu=(a>b).ni Indicator bits ni=(a<b).a First number to compare. b Second number to compare. twosComplement When set to true, the inputs are signed integers in 2's complement. If set tofalse(default), unsigned comparison is performed.unpackSlotEncoding Vector of constants for unpacking, as used in bootstrapping.
- Note
- If
a=bthenmu=ni=0
◆ compareTwoNumbersImplementation()
| void helib::compareTwoNumbersImplementation | ( | CtPtrs & | max, |
| CtPtrs & | min, | ||
| Ctxt & | mu, | ||
| Ctxt & | ni, | ||
| const CtPtrs & | aa, | ||
| const CtPtrs & | bb, | ||
| bool | twosComplement, | ||
| std::vector< zzX > * | unpackSlotEncoding, | ||
| bool | cmp_only | ||
| ) |
◆ computeAllProducts()
| void helib::computeAllProducts | ( | CtPtrs & | products, |
| const CtPtrs & | array, | ||
| std::vector< zzX > * | unpackSlotEncoding = nullptr |
||
| ) |
For an n-size array, compute the 2^n products products[j] = \prod_{i s.t. j_i=1} array[i] \times \prod_{i s.t. j_i=0}(a-array[i])
◆ computeDivVec()
|
inline |
◆ computeIntervalForMul()
| void helib::computeIntervalForMul | ( | double & | lo, |
| double & | hi, | ||
| const Ctxt & | ctxt1, | ||
| const Ctxt & | ctxt2 | ||
| ) |
◆ computeIntervalForSqr()
| void helib::computeIntervalForSqr | ( | double & | lo, |
| double & | hi, | ||
| const Ctxt & | ctxt | ||
| ) |
◆ computeInvVec()
|
inline |
◆ ComputeOneGenMapping()
| void helib::ComputeOneGenMapping | ( | Permut & | genMap, |
| const OneGeneratorTree & | T | ||
| ) |
to a single generator tree
◆ computeProd() [1/2]
| long helib::computeProd | ( | const NTL::Vec< long > & | vec | ) |
returns \prod_d vec[d]
◆ computeProd() [2/2]
| long helib::computeProd | ( | const std::vector< long > & | vec | ) |
◆ concatBinaryNums()
Concatenates two binary numbers into a single CtPtrs object. E.g. If a=10111, b=00101 then output = 1011100101.
Concatenate two binary numbers into a single CtPtrs object.
- Parameters
-
output Equal to the concatenation of aandb.a First number to copy into output.b Second number to concatenate to a.
- Note
- The size of
outputmust be of sizea.size() + b.size().
◆ conv() [1/2]
|
inline |
◆ conv() [2/2]
|
inline |
◆ convert() [1/18]
template<typename T1 , typename T2 >
| T1 helib::convert | ( | const T2 & | v2 | ) |
◆ convert() [2/18]
|
inline |
◆ convert() [3/18]
|
inline |
◆ convert() [4/18]
| void helib::convert | ( | NTL::GF2X & | out, |
| const NTL::Vec< long > & | in | ||
| ) |
◆ convert() [5/18]
| void helib::convert | ( | NTL::mat_zz_pE & | X, |
| const std::vector< std::vector< NTL::ZZX >> & | A | ||
| ) |
◆ convert() [6/18]
| void helib::convert | ( | NTL::Vec< long > & | out, |
| const NTL::GF2X & | in | ||
| ) |
◆ convert() [7/18]
| void helib::convert | ( | NTL::Vec< long > & | out, |
| const NTL::zz_pX & | in, | ||
| bool | symmetric = true |
||
| ) |
◆ convert() [8/18]
| void helib::convert | ( | NTL::Vec< long > & | out, |
| const NTL::ZZX & | in | ||
| ) |
◆ convert() [9/18]
template<typename T1 , typename T2 >
| void helib::convert | ( | NTL::Vec< T1 > & | v1, |
| const std::vector< T2 > & | v2 | ||
| ) |
◆ convert() [10/18]
| void helib::convert | ( | NTL::vec_zz_pE & | X, |
| const std::vector< NTL::ZZX > & | A | ||
| ) |
◆ convert() [11/18]
|
inline |
◆ convert() [12/18]
| void helib::convert | ( | NTL::ZZX & | out, |
| const NTL::Vec< long > & | in | ||
| ) |
◆ convert() [13/18]
| void helib::convert | ( | std::vector< NTL::ZZX > & | X, |
| const NTL::vec_zz_pE & | A | ||
| ) |
◆ convert() [14/18]
| void helib::convert | ( | std::vector< std::vector< NTL::ZZX >> & | X, |
| const NTL::mat_zz_pE & | A | ||
| ) |
◆ convert() [15/18]
template<typename T >
| void helib::convert | ( | std::vector< T > & | v1, |
| const std::vector< T > & | v2 | ||
| ) |
Trivial type conversion, useful for generic code.
◆ convert() [16/18]
template<typename T1 , typename T2 >
| void helib::convert | ( | std::vector< T1 > & | v1, |
| const NTL::Vec< T2 > & | v2 | ||
| ) |
◆ convert() [17/18]
template<typename T1 , typename T2 >
| void helib::convert | ( | std::vector< T1 > & | v1, |
| const std::vector< T2 > & | v2 | ||
| ) |
generic vector conversion routines
◆ convert() [18/18]
template<typename T1 , typename T2 >
| void helib::convert | ( | T1 & | x1, |
| const T2 & | x2 | ||
| ) |
A generic template that resolves to NTL's conv routine.
◆ convertDataToSlotVector()
template<typename From , typename Scheme >
|
inline |
◆ CRTcoeff()
|
inline |
Returns a CRT coefficient: x = (0 mod p, 1 mod q). If symmetric is set then x \in [-pq/2, pq/2), else x \in [0,pq)
◆ Cyclotomic()
| NTL::ZZX helib::Cyclotomic | ( | long | N | ) |
Compute cyclotomic polynomial.
◆ decode() [1/2]
| void helib::decode | ( | const EncryptedArray & | ea, |
| std::vector< long > & | array, | ||
| const PlaintextArray & | pa | ||
| ) |
◆ decode() [2/2]
| void helib::decode | ( | const EncryptedArray & | ea, |
| std::vector< NTL::ZZX > & | array, | ||
| const PlaintextArray & | pa | ||
| ) |
◆ decryptAndCompare()
| bool helib::decryptAndCompare | ( | const Ctxt & | ctxt, |
| const SecKey & | sk, | ||
| const EncryptedArray & | ea, | ||
| const PlaintextArray & | pa | ||
| ) |
◆ decryptAndPrint()
| void helib::decryptAndPrint | ( | std::ostream & | s, |
| const Ctxt & | ctxt, | ||
| const SecKey & | sk, | ||
| const EncryptedArray & | ea, | ||
| long | flags = 0 |
||
| ) |
◆ decryptBinaryNums()
| void helib::decryptBinaryNums | ( | std::vector< long > & | pNums, |
| const CtPtrs & | eNums, | ||
| const SecKey & | sKey, | ||
| const EncryptedArray & | ea, | ||
| bool | twosComplement = false, |
||
| bool | allSlots = true |
||
| ) |
Decrypt the binary numbers that are encrypted in eNums.
- Parameters
-
pNums vector to decrypt the binary numbers into. eNums encrypted binary numbers of which to be decrypted. sKey secret key used for decryption. ea encrypted array that holds necessary information for decryption. twosComplement when set to true, the number to decrypt is a signed integer in 2's complement. allSlots when set to false, return only the sub-cube with index=0 in the last dimension within each ciphertext.
The bits are encrypted in a bit-sliced manner. Namely, encNums[0] contains the LSB of all the numbers, encNums[1] the next bits from all, etc. If twosComplement==true then the number is interpreted as a signed integer in 2's-complement representation. If allSlots==false then we only return the subcube with index i=0 in the last dimension within each ciphertext. Namely, the bit for the j'th counter is found in slot of index j*sizeOf(lastDim).
◆ defaultPmiddle()
|
inline |
◆ defaultQmiddle()
|
inline |
◆ deserialize() [1/3]
| void helib::deserialize | ( | std::istream & | is, |
| PolyMod & | poly | ||
| ) |
- Parameters
-
is Input std::istream.poly Destination PolyModobject.
- Exceptions
-
IOError if the stream is badly formatted (i.e. it is not delimited by '[' and ']').
- Note
polymust be constructed with an appropriate p2r and G BEFORE calling this function. For example,PolyMod my_poly(p2r, G);deserialize(std::cin, my_poly);
The input stream has to be formatted as a comma-separated list surrounded by '[' and ']'.
Each element of the list will be deserialized as a coefficient of the polynomial.
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.
◆ deserialize() [2/3]
template<typename Scheme >
| void helib::deserialize | ( | std::istream & | is, |
| Ptxt< Scheme > & | ptxt | ||
| ) |
Function to deserialize a Ptxt<Scheme>.
- Parameters
-
is Input std::istream.ptxt Destination Ptxtobject.
- Exceptions
-
IOError if the stream is badly formatted (i.e. it is not delimited by '[' and ']').
- Note
ptxtmust be constructed with an appropriate context BEFORE calling this function. For example,Ptxt my_ptxt(context);deserialize(std::cin, my_ptxt);
The input stream has to be formatted as a comma-separated list surrounded by '[' and ']'.
Each element of the list will be deserialized as a slot of the type determined by the scheme.
If the number of tokens in the list is less than the number of slots, the remaining slots will be padded by 0.
For example '['slot0', 'slot1', 'slot2']' will be deserialized as a plaintext ptxt where ptxt[0]=slot0, ptxt[1]=slot1, ptxt[2]=slot2 and ptxt[i]=0 for i>2.
◆ deserialize() [3/3]
| void helib::deserialize | ( | std::istream & | is, |
| std::complex< double > & | num | ||
| ) |
Deserialize a std::complex<double> from the input stream is delimited by '[' and ']' (instead of the default '(', ')').
- Parameters
-
is The input stream reference. num The complex number to deserialize.
- Exceptions
-
IOError if the stream contains more than 2 parts.
The input stream has to be formatted as '['number']' (this will be deserialized as (number, 0)) or '['real_part', 'imag_part']' (this will be deserialized as (real_part, imag_part)).
◆ deserialize< BGV >()
| template void helib::deserialize< BGV > | ( | std::istream & | is, |
| Ptxt< BGV > & | ptxt | ||
| ) |
◆ deserialize< CKKS >()
| template void helib::deserialize< CKKS > | ( | std::istream & | is, |
| Ptxt< CKKS > & | ptxt | ||
| ) |
◆ DestMulAdd()
| void helib::DestMulAdd | ( | Ctxt & | x, |
| const std::shared_ptr< ConstMultiplier > & | a, | ||
| Ctxt & | b | ||
| ) |
◆ disjoint()
◆ div() [1/2]
| void helib::div | ( | std::vector< NTL::ZZX > & | x, |
| const std::vector< NTL::ZZX > & | a, | ||
| long | b | ||
| ) |
◆ div() [2/2]
◆ divc()
|
inline |
returns ceiling(a/b); assumes a >=0, b>0, a+b <= MAX_LONG
◆ DoubleCRT::Op< DoubleCRT::AddFun >() [1/3]
| template DoubleCRT& helib::DoubleCRT::Op< DoubleCRT::AddFun > | ( | const DoubleCRT & | other, |
| AddFun | fun, | ||
| bool | matchIndexSets | ||
| ) |
◆ DoubleCRT::Op< DoubleCRT::AddFun >() [2/3]
| template DoubleCRT& helib::DoubleCRT::Op< DoubleCRT::AddFun > | ( | const NTL::ZZ & | num, |
| AddFun | fun | ||
| ) |
◆ DoubleCRT::Op< DoubleCRT::AddFun >() [3/3]
| template DoubleCRT& helib::DoubleCRT::Op< DoubleCRT::AddFun > | ( | const NTL::ZZX & | poly, |
| AddFun | fun | ||
| ) |
◆ DoubleCRT::Op< DoubleCRT::MulFun >() [1/2]
| template DoubleCRT& helib::DoubleCRT::Op< DoubleCRT::MulFun > | ( | const NTL::ZZ & | num, |
| MulFun | fun | ||
| ) |
◆ DoubleCRT::Op< DoubleCRT::MulFun >() [2/2]
| template DoubleCRT& helib::DoubleCRT::Op< DoubleCRT::MulFun > | ( | const NTL::ZZX & | poly, |
| MulFun | fun | ||
| ) |
◆ DoubleCRT::Op< DoubleCRT::SubFun >() [1/3]
| template DoubleCRT& helib::DoubleCRT::Op< DoubleCRT::SubFun > | ( | const DoubleCRT & | other, |
| SubFun | fun, | ||
| bool | matchIndexSets | ||
| ) |
◆ DoubleCRT::Op< DoubleCRT::SubFun >() [2/3]
| template DoubleCRT& helib::DoubleCRT::Op< DoubleCRT::SubFun > | ( | const NTL::ZZ & | num, |
| SubFun | fun | ||
| ) |
◆ DoubleCRT::Op< DoubleCRT::SubFun >() [3/3]
| template DoubleCRT& helib::DoubleCRT::Op< DoubleCRT::SubFun > | ( | const NTL::ZZX & | poly, |
| SubFun | fun | ||
| ) |
◆ EDF()
| void helib::EDF | ( | NTL::vec_zz_pX & | v, |
| const NTL::zz_pX & | f, | ||
| long | d | ||
| ) |
◆ embeddingLargestCoeff() [1/4]
◆ embeddingLargestCoeff() [2/4]
| NTL::xdouble helib::embeddingLargestCoeff | ( | const NTL::ZZX & | f, |
| const PAlgebra & | palg | ||
| ) |
◆ embeddingLargestCoeff() [3/4]
| double helib::embeddingLargestCoeff | ( | const std::vector< double > & | f, |
| const PAlgebra & | palg | ||
| ) |
◆ embeddingLargestCoeff() [4/4]
Computing the L-infinity norm of the canonical embedding Assumed: deg(f) < phi(m).
◆ embeddingLargestCoeff_x2()
| void helib::embeddingLargestCoeff_x2 | ( | double & | norm1, |
| double & | norm2, | ||
| const std::vector< double > & | f1, | ||
| const std::vector< double > & | f2, | ||
| const PAlgebra & | palg | ||
| ) |
◆ empty()
|
inline |
◆ encode() [1/4]
| void helib::encode | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| const NTL::ZZX & | val | ||
| ) |
◆ encode() [2/4]
| void helib::encode | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| const std::vector< long > & | array | ||
| ) |
◆ encode() [3/4]
| void helib::encode | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| const std::vector< NTL::ZZX > & | array | ||
| ) |
◆ encode() [4/4]
| void helib::encode | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| long | val | ||
| ) |
◆ endBuildModChain()
| void helib::endBuildModChain | ( | Context & | context | ) |
◆ equals() [1/3]
| bool helib::equals | ( | const EncryptedArray & | ea, |
| const PlaintextArray & | pa, | ||
| const PlaintextArray & | other | ||
| ) |
◆ equals() [2/3]
| bool helib::equals | ( | const EncryptedArray & | ea, |
| const PlaintextArray & | pa, | ||
| const std::vector< long > & | other | ||
| ) |
◆ equals() [3/3]
| bool helib::equals | ( | const EncryptedArray & | ea, |
| const PlaintextArray & | pa, | ||
| const std::vector< NTL::ZZX > & | other | ||
| ) |
◆ extendExtractDigits()
◆ extractDigits() [1/2]
|
inline |
◆ extractDigits() [2/2]
Extract the mod-p digits of a mod-p^r ciphertext.
extractDigits returns in the slots of digits[j] the j'th-lowest digits from the integers in the slots of the input. Namely, the i'th slot of digits[j] contains the j'th digit in the p-base expansion of the integer in the i'th slot of the *this.
If r==0 then it is set to c.effectiveR(). It is assumed that the slots of *this contains integers mod p^r, i.e., that only the free terms are nonzero. If that assumptions does not hold then the result will not be a valid ciphertext anymore.
The "shortcut" flag is deprecated, it often leads to catastrophic failure in the noise estimate. Calling the function with shortcut=true has not effect, except printing a warning message to cerr.
The output ciphertext digits[j] contains the j'th digit in the base-p expansion of the input, and its plaintext space is modulo p^{r-j}. All the ciphertexts in the output are at the same level.
◆ extractDigitsPacked()
| void helib::extractDigitsPacked | ( | Ctxt & | ctxt, |
| long | botHigh, | ||
| long | r, | ||
| long | ePrime, | ||
| const std::vector< NTL::ZZX > & | unpackSlotEncoding | ||
| ) |
◆ extractDigitsThin()
| void helib::extractDigitsThin | ( | Ctxt & | ctxt, |
| long | botHigh, | ||
| long | r, | ||
| long | ePrime | ||
| ) |
◆ extractTokenizeRegion()
| std::vector< std::stringstream > helib::extractTokenizeRegion | ( | std::istream & | istr, |
| char | begin_char, | ||
| char | end_char, | ||
| char | separator, | ||
| bool | skip_space = true |
||
| ) |
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.
- Parameters
-
istr The stream to be advanced. begin_char The character determining the beginning of the region-of-interest. end_char The character determining the end of the region-of-interest separator The separator character to split at. skip_space Boolean value determining whether to skip spaces when extracting the sub-streams (default = true).
- Returns
- A
std::vector<std::stringstream>with the stream of every section of the input region.
- Exceptions
-
IOError If the stream is badly formatted (i.e. it does not start with begin_charor it does not end withend_char).
- Note
- Requires
begin_char,end_charandseparatorto be distinct and different from (space).
◆ factorize() [1/3]
| void helib::factorize | ( | NTL::Vec< NTL::Pair< long, long >> & | factors, |
| long | N | ||
| ) |
Factoring by trial division, only works for N<2^{60} primes and multiplicities are recorded.
◆ factorize() [2/3]
| void helib::factorize | ( | std::vector< long > & | factors, |
| long | N | ||
| ) |
Factoring by trial division, only works for N<2^{60}, only the primes are recorded, not their multiplicity.
◆ factorize() [3/3]
| void helib::factorize | ( | std::vector< NTL::ZZ > & | factors, |
| const NTL::ZZ & | N | ||
| ) |
◆ fastPower()
| void helib::fastPower | ( | Ctxt & | ctxt, |
| long | d | ||
| ) |
◆ fetch_saved_values()
| const std::vector< double > * helib::fetch_saved_values | ( | const char * | name | ) |
◆ fifteenOrLess4Four()
Add together up to fifteen {0,1} integers, producing a 4-bit counter.
- Parameters
-
out 4-bit counter to be outputted. in bits to be counted. sizeLimit number of bits to compute on, taken from the least significant end.
- Returns
- number of output bits that are not identically zero (i.e. != null).
Adding fifteen input bits, getting a 4-bit counter. Some of the input pointers may be null, but output pointers must point to allocated Ctxt objects. If sizeLimit<4, only that many bits are computed (taken from the least significant end).
- Note
- This function is currently not thread safe.
◆ findGenerators()
| long helib::findGenerators | ( | std::vector< long > & | gens, |
| std::vector< long > & | ords, | ||
| long | m, | ||
| long | p, | ||
| const std::vector< long > & | candidates = std::vector<long>() |
||
| ) |
Returns in gens a generating set for Zm* /
, and in ords the order of these generators. Return value is the order of p in Zm*.
◆ FindM()
| long helib::FindM | ( | long | k, |
| long | nBits, | ||
| long | c, | ||
| long | p, | ||
| long | d, | ||
| long | s, | ||
| long | chosen_m, | ||
| bool | verbose = false |
||
| ) |
Returns smallest parameter m satisfying various constraints:
- Parameters
-
k security parameter L number of levels c number of columns in key switching matrices p characteristic of plaintext space d embedding degree (d ==0 or d==1 => no constraint) s at least that many plaintext slots chosen_m preselected value of m (0 => not preselected) Fails with an error message if no suitable m is found prints an informative message if verbose == true
◆ findMinBitCapacity() [1/3]
|
inline |
◆ findMinBitCapacity() [2/3]
|
inline |
◆ findMinBitCapacity() [3/3]
|
inline |
◆ FindPrimitiveRoot() [1/2]
| void helib::FindPrimitiveRoot | ( | NTL::zz_p & | r, |
| unsigned long | e | ||
| ) |
Find e-th root of unity modulo the current modulus.
◆ FindPrimitiveRoot() [2/2]
| void helib::FindPrimitiveRoot | ( | NTL::ZZ_p & | r, |
| unsigned long | e | ||
| ) |
◆ FindPrimRootT()
template<typename zp , typename zz >
| void helib::FindPrimRootT | ( | zp & | root, |
| unsigned long | e | ||
| ) |
◆ frobeniusAutomorph() [1/2]
| void helib::frobeniusAutomorph | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| const NTL::Vec< long > & | vec | ||
| ) |
◆ frobeniusAutomorph() [2/2]
| void helib::frobeniusAutomorph | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| long | j | ||
| ) |
◆ FrobeniusMap()
| NTL::zz_pEX helib::FrobeniusMap | ( | const NTL::zz_pEXModulus & | F | ) |
◆ fsquare()
|
inline |
Return the square of a number as a double.
◆ GenBabySteps()
| void helib::GenBabySteps | ( | std::vector< std::shared_ptr< Ctxt >> & | v, |
| const Ctxt & | ctxt, | ||
| long | dim, | ||
| bool | clean | ||
| ) |
◆ getG()
| NTL::ZZX helib::getG | ( | const EncryptedArray & | ea | ) |
◆ getHyperColumn() [1/3]
| template void helib::getHyperColumn | ( | NTL::Vec< long > & | v, |
| const ConstCubeSlice< long > & | s, | ||
| long | pos | ||
| ) |
◆ getHyperColumn() [2/3]
| template void helib::getHyperColumn | ( | NTL::Vec< NTL::zz_p > & | v, |
| const ConstCubeSlice< NTL::zz_p > & | s, | ||
| long | pos | ||
| ) |
◆ getHyperColumn() [3/3]
template<typename T >
| void helib::getHyperColumn | ( | NTL::Vec< T > & | v, |
| const ConstCubeSlice< T > & | s, | ||
| long | pos | ||
| ) |
getHyperColumn reads out a (multi-dimensional) column from a slice. The parameter pos specifies the position of the column, which must be in the range 0 <= pos < s.getProd(1). The vector v is filled with values whose coordinate in the lower dimensional subcube is equal to pos. The length of v will be set to s.getDim(0).
◆ getPhimXMod()
| const NTL::zz_pXModulus & helib::getPhimXMod | ( | const PAlgebra & | palg | ) |
◆ getTimerByName()
| const FHEtimer * helib::getTimerByName | ( | const char * | name | ) |
◆ GetTimerClock()
| unsigned long helib::GetTimerClock | ( | ) |
◆ incrementalProduct()
| void helib::incrementalProduct | ( | std::vector< Ctxt > & | v | ) |
For i=n-1...0, set v[i]=prod_{j<=i} v[j] This implementation uses depth log n and (nlog n)/2 products
◆ incrementalZeroTest()
| void helib::incrementalZeroTest | ( | Ctxt * | res[], |
| const EncryptedArray & | ea, | ||
| const Ctxt & | ctxt, | ||
| long | n | ||
| ) |
◆ innerProduct() [1/9]
◆ innerProduct() [2/9]
◆ innerProduct() [3/9]
|
inline |
◆ innerProduct() [4/9]
|
inline |
◆ innerProduct() [5/9]
◆ innerProduct() [6/9]
| void helib::innerProduct | ( | Ctxt & | result, |
| const std::vector< Ctxt > & | v1, | ||
| const std::vector< Ctxt > & | v2 | ||
| ) |
◆ innerProduct() [7/9]
| void helib::innerProduct | ( | Ctxt & | result, |
| const std::vector< Ctxt > & | v1, | ||
| const std::vector< DoubleCRT > & | v2 | ||
| ) |
Compute the inner product of a vectors of ciphertexts and a constant vector.
◆ innerProduct() [8/9]
| void helib::innerProduct | ( | Ctxt & | result, |
| const std::vector< Ctxt > & | v1, | ||
| const std::vector< NTL::ZZX > & | v2 | ||
| ) |
◆ innerProduct() [9/9]
template<typename Scheme >
| void helib::innerProduct | ( | Ptxt< Scheme > & | result, |
| const std::vector< Ptxt< Scheme >> & | first_vec, | ||
| const std::vector< Ptxt< Scheme >> & | second_vec | ||
| ) |
Free function that computes the inner product of two vectors of Ptxt.
- Parameters
-
result The output Ptxtthat will hold the result.first_vec The first input vector of plaintexts. second_vec The second input vector of plaintexts.
- Note
- If the two vector sizes differ, the shorter vector will be padded with zeroes.
◆ interpolateMod()
| void helib::interpolateMod | ( | NTL::ZZX & | poly, |
| const NTL::vec_long & | x, | ||
| const NTL::vec_long & | y, | ||
| long | p, | ||
| long | e = 1 |
||
| ) |
Interpolate polynomial such that poly(x[i] mod p)=y[i] (mod p^e) It is assumed that the points x[i] are all distinct modulo p.
◆ intVecCRT() [1/4]
| template bool helib::intVecCRT | ( | NTL::vec_ZZ & | , |
| const NTL::ZZ & | , | ||
| const NTL::Vec< NTL::zz_p > & | , | ||
| long | |||
| ) |
◆ intVecCRT() [2/4]
| template bool helib::intVecCRT | ( | NTL::vec_ZZ & | , |
| const NTL::ZZ & | , | ||
| const NTL::vec_long & | , | ||
| long | |||
| ) |
◆ intVecCRT() [3/4]
| template bool helib::intVecCRT | ( | NTL::vec_ZZ & | , |
| const NTL::ZZ & | , | ||
| const NTL::vec_ZZ & | , | ||
| long | |||
| ) |
◆ intVecCRT() [4/4]
template<class zzvec >
| bool helib::intVecCRT | ( | NTL::vec_ZZ & | vp, |
| const NTL::ZZ & | p, | ||
| const zzvec & | vq, | ||
| long | q | ||
| ) |
Incremental integer CRT for vectors.
Expects co-primes p,q with q odd, and such that all the entries in v1 are in [-p/2,p/2). Returns in v1 the CRT of vp mod p and vq mod q, as integers in [-pq/2, pq/2). Uses the formula:
![\[ CRT(vp,p,vq,q) = vp + [(vq-vp) * p^{-1}]_q * p, \]](form_4.png)
where [...]_q means reduction to the interval [-q/2,q/2). Notice that if q is odd then this is the same as reducing to [-(q-1)/2,(q-1)/2], which means that [...]_q * p is in [-p(q-1)/2, p(q-1)/2], and since vp is in [-p/2,p/2) then the sum is indeed in [-pq/2,pq/2).
Return true is both vectors are of the same length, false otherwise
◆ InvModpr()
| void helib::InvModpr | ( | NTL::zz_pX & | S, |
| const NTL::zz_pX & | F, | ||
| const NTL::zz_pX & | G, | ||
| long | p, | ||
| long | r | ||
| ) |
◆ is2power()
|
inline |
◆ is_in()
| long helib::is_in | ( | long | x, |
| int * | X, | ||
| long | sz | ||
| ) |
Finds whether x is an element of the set X of size sz, Returns -1 it not and the location if true.
◆ isDryRun()
|
inline |
◆ isSetAutomorphVals()
|
inline |
◆ isSetAutomorphVals2()
|
inline |
◆ IsZero()
|
inline |
◆ iterateInterestRegion()
| bool helib::iterateInterestRegion | ( | std::istream & | str, |
| int | begin_char, | ||
| int | separator, | ||
| int | end_char | ||
| ) |
Advance the input stream str beyond white spaces and a single separator in the region-of-interest delimited by begin_char and end_char.
- Parameters
-
str The stream to be advanced. begin_char The character determining the beginning of the region-of-interest (to advance beyond of). separator The separator character to advance beyond of. end_char The character determining the end of the region-of-interest (to advance beyond of).
- Returns
trueif the region-of-interest is not completed (i.e.:end_charis not reached).falseotherwise.
- Note
- Throws
helib::RuntimeErrorif after spaces there is a character different frombegin_char,beyond, orend_char.
◆ killVec() [1/2]
template<typename T >
| void helib::killVec | ( | NTL::Vec< T > & | vec | ) |
◆ killVec() [2/2]
template<typename T >
| void helib::killVec | ( | std::vector< T > & | vec | ) |
NTL/std compatibility.
◆ KSGiantStepSize()
| long helib::KSGiantStepSize | ( | long | D | ) |
Function that returns number of baby steps. Used to keep this and matmul routines "in sync".
◆ largestCoeff() [1/5]
| NTL::ZZ helib::largestCoeff | ( | const DoubleCRT & | f | ) |
◆ largestCoeff() [2/5]
| NTL::ZZ helib::largestCoeff | ( | const NTL::Vec< NTL::ZZ > & | f | ) |
◆ largestCoeff() [3/5]
template<typename T >
| double helib::largestCoeff | ( | const NTL::Vec< T > & | f | ) |
The L-infinity norm of an element (in coefficient representation)
◆ largestCoeff() [4/5]
| NTL::ZZ helib::largestCoeff | ( | const NTL::ZZX & | f | ) |
◆ largestCoeff() [5/5]
template<typename T >
| double helib::largestCoeff | ( | const std::vector< T > & | f | ) |
◆ leftBitwiseShift()
Left shift input by shamt.
Shift binary numbers to the left by shamt
- Parameters
-
output Shifted result. input The number to be shifted. shamt The number to bits to shift by.
- Note
- This is a left shift only, i.e. the bits are moved to the most-significant end.
-
shamtmust be positive. -
The size of
outputandinputmust be the same.
◆ length()
| long helib::length | ( | GenNodePtr | ptr | ) |
◆ less_than() [1/8]
| bool helib::less_than | ( | const NTL::GF2E & | a, |
| const NTL::GF2E & | b | ||
| ) |
◆ less_than() [2/8]
| bool helib::less_than | ( | const NTL::GF2EX & | a, |
| const NTL::GF2EX & | b | ||
| ) |
◆ less_than() [3/8]
| bool helib::less_than | ( | const NTL::GF2X & | a, |
| const NTL::GF2X & | b | ||
| ) |
◆ less_than() [4/8]
| bool helib::less_than | ( | const NTL::zz_pE & | a, |
| const NTL::zz_pE & | b | ||
| ) |
◆ less_than() [5/8]
| bool helib::less_than | ( | const NTL::zz_pEX & | a, |
| const NTL::zz_pEX & | b | ||
| ) |
◆ less_than() [6/8]
| bool helib::less_than | ( | const NTL::zz_pX & | a, |
| const NTL::zz_pX & | b | ||
| ) |
◆ less_than() [7/8]
| bool helib::less_than | ( | NTL::GF2 | a, |
| NTL::GF2 | b | ||
| ) |
◆ less_than() [8/8]
| bool helib::less_than | ( | NTL::zz_p | a, |
| NTL::zz_p | b | ||
| ) |
◆ log2()
|
inline |
Base-2 logarithm.
◆ log2_realToEstimatedNoise()
◆ longToBitVector()
| std::vector< long > helib::longToBitVector | ( | long | num, |
| long | bitSize | ||
| ) |
Returns a number as a vector of bits with LSB on the left.
- Parameters
-
num Number to be converted. bitSize Number of bits of the input and output.
- Returns
- Bit vector representation of num.
- Note
bitSizemust be non-negative.
◆ lsize() [1/4]
template<typename T >
|
inline |
◆ lsize() [2/4]
template<typename T >
| long helib::lsize | ( | const PtrMatrix< T > & | v | ) |
◆ lsize() [3/4]
template<typename T >
| long helib::lsize | ( | const PtrVector< T > & | v | ) |
◆ lsize() [4/4]
template<typename T >
|
inline |
Size of STL vector as a long (rather than unsigned long)
◆ lweEstimateSecurity()
|
inline |
An estimate for the security-level. This has a lower bound of 0.
This function uses experimental affine approximations to the lwe-estimator from https://bitbucket.org/malb/lwe-estimator/raw/HEAD/estimator.py, from Aug-2020 (see script in misc/estimator/lwe-estimator.sage). Let X = n / log(1/alpha), the security level is estimated as follows:
- dense {-1,0,1} keys: security ~ 3.8*X -20
- sparse keys (weight=450): security ~ 3.55*X -12
- sparse keys (weight=420): security ~ 3.5*X -10
- sparse keys (weight=390): security ~ 3.45*X -7
- sparse keys (weight=360): security ~ 3.4*X -5
- sparse keys (weight=330): security ~ 3.35*X -4
- sparse keys (weight=300): security ~ 3.3*X -3
- sparse keys (weight=270): security ~ 3.2*X +1
- sparse keys (weight=240): security ~ 3.1*X +3
- sparse keys (weight=210): security ~ 3*X +6
- sparse keys (weight=180): security ~ 2.83*X +10
- sparse keys (weight=150): security ~ 2.67*X +13
- sparse keys (weight=120): security ~ 2.4*X +19
◆ make_lazy()
template<typename T , typename P , typename... Args>
| void helib::make_lazy | ( | const NTL::Lazy< T, P > & | obj, |
| Args &&... | args | ||
| ) |
This should go in NTL some day... Just call as make_lazy(obj, ...) to initialize a lazy object via a call to a constructor T(...)
◆ make_lazy_with_fun()
template<typename T , typename P , typename F , typename... Args>
| void helib::make_lazy_with_fun | ( | const NTL::Lazy< T, P > & | obj, |
| F | f, | ||
| Args &&... | args | ||
| ) |
This should go in NTL some day... Just call as make_lazy(obj, f, ....) to initialize a lazy object via a call to f(*obj, ...)
◆ makeIrredPoly()
| NTL::ZZX helib::makeIrredPoly | ( | long | p, |
| long | d | ||
| ) |
Return a degree-d irreducible polynomial mod p.
◆ makeQueryExpr()
|
inline |
Utility function for creating a shared pointer to a specified column in a query.
- Parameters
-
cl The index of the column to be used in the query.
- Returns
- Shared pointer to the class
ColNumber.
◆ mapTo01() [1/4]
| template void helib::mapTo01 | ( | const EncryptedArray & | , |
| Ptxt< BGV > & | ptxt | ||
| ) |
◆ mapTo01() [2/4]
| template void helib::mapTo01 | ( | const EncryptedArray & | , |
| Ptxt< CKKS > & | ptxt | ||
| ) |
◆ mapTo01() [3/4]
template<typename Scheme >
| void helib::mapTo01 | ( | const EncryptedArray & | , |
| Ptxt< Scheme > & | ptxt | ||
| ) |
◆ mapTo01() [4/4]
| void helib::mapTo01 | ( | const EncryptedArray & | ea, |
| Ctxt & | ctxt | ||
| ) |
◆ max_abs() [1/2]
|
inline |
◆ max_abs() [2/2]
|
inline |
Simple routine for computing the max-abs of a vector of complex numbers and real numbers
◆ maximum_flow()
| long helib::maximum_flow | ( | FlowGraph & | fg, |
| long | src, | ||
| long | sink | ||
| ) |
Remove from the graph all the flow-zero edges for (long i=0; i<(long)fg.size(); i++) { FNeighborList::iterator it1=fg[i].begin(); do { FNeighborList::iterator it2 = it1; it1++; // increment the iterator before potentially erasing the edge if (it2->second.flow == 0) fg[i].erase(it2); } while (it1 != fg[i].end()); }
Remove from the graph all the flow-zero edges for (long i=0; i<(long)fg.size(); i++) { FNeighborList::iterator it1=fg[i].begin(); do { FNeighborList::iterator it2 = it1; it1++; // increment the iterator before potentially erasing the edge if (it2->second.flow == 0) fg[i].erase(it2); } while (it1 != fg[i].end()); }
◆ mcDiv()
| long helib::mcDiv | ( | long | a, |
| long | b | ||
| ) |
◆ mcMod()
| long helib::mcMod | ( | long | a, |
| long | b | ||
| ) |
Routines for computing mathematically correct mod and div.
mcDiv(a, b) = floor(a / b), mcMod(a, b) = a - b*mcDiv(a, b); in particular, mcMod(a, b) is 0 or has the same sign as b
◆ mobius()
| long helib::mobius | ( | long | n | ) |
Compute mobius function (naive method as n is small).
◆ ModComp()
| void helib::ModComp | ( | NTL::ZZX & | res, |
| const NTL::ZZX & | g, | ||
| const NTL::ZZX & | h, | ||
| const NTL::ZZX & | f | ||
| ) |
Modular composition of polynomials: res = g(h) mod f.
◆ mul() [1/7]
| void helib::mul | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| const PlaintextArray & | other | ||
| ) |
◆ mul() [2/7]
| void helib::mul | ( | PlaintextArray & | pa, |
| const BlockMatMul1D & | mat | ||
| ) |
◆ mul() [3/7]
| void helib::mul | ( | PlaintextArray & | pa, |
| const BlockMatMulFull & | mat | ||
| ) |
◆ mul() [4/7]
| void helib::mul | ( | PlaintextArray & | pa, |
| const MatMul1D & | mat | ||
| ) |
◆ mul() [5/7]
| void helib::mul | ( | PlaintextArray & | pa, |
| const MatMulFull & | mat | ||
| ) |
◆ mul() [6/7]
| void helib::mul | ( | std::vector< NTL::ZZX > & | x, |
| const std::vector< NTL::ZZX > & | a, | ||
| long | b | ||
| ) |
◆ mul() [7/7]
◆ MulAdd()
| void helib::MulAdd | ( | Ctxt & | x, |
| const std::shared_ptr< ConstMultiplier > & | a, | ||
| const Ctxt & | b | ||
| ) |
◆ MulMod() [1/6]
|
inline |
◆ MulMod() [2/6]
|
inline |
◆ MulMod() [3/6]
◆ MulMod() [4/6]
|
inline |
◆ MulMod() [5/6]
| void helib::MulMod | ( | NTL::ZZX & | out, |
| const NTL::ZZX & | f, | ||
| long | a, | ||
| long | q, | ||
| bool | abs | ||
| ) |
◆ MulMod() [6/6]
◆ multOrd()
| long helib::multOrd | ( | long | p, |
| long | m | ||
| ) |
Return multiplicative order of p modulo m, or 0 if GCD(p, m) != 1.
◆ multTwoNumbers()
| void helib::multTwoNumbers | ( | CtPtrs & | product, |
| const CtPtrs & | lhs, | ||
| const CtPtrs & | rhs, | ||
| bool | rhsTwosComplement = false, |
||
| long | sizeLimit = 0, |
||
| std::vector< zzX > * | unpackSlotEncoding = nullptr |
||
| ) |
Multiply two numbers in binary representation where each ciphertext of the input vector contains a bit.
- Parameters
-
product result of the multiplication operation. lhs left hand side of the multiplication. rhs right hand side of the multiplication. rhsTwosComplement flag to state the multiplier is potentially negative. sizeLimit number of bits to compute on, taken from the least significant end. unpackSlotEncoding vector of constants for unpacking, as used in bootstrapping.
◆ negate()
| void helib::negate | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa | ||
| ) |
◆ negateBinary()
Negates a number in binary 2's complement representation.
- Parameters
-
negation Reference to the negated number that will be populated. input Number to be negated.
- Note
inputwill be treated as a number in 2's complement.-
inputmust not alias negation.
◆ normalize()
| void helib::normalize | ( | zzX & | f | ) |
◆ operator!=()
template<typename T >
| bool helib::operator!= | ( | const IndexMap< T > & | map1, |
| const IndexMap< T > & | map2 | ||
| ) |
◆ operator&()
◆ operator&&()
Overloaded operator for creating a shared pointer to an AND expression.
- Parameters
-
lhs Left operand of the AND expression. rhs Right operand of the AND expression.
- Returns
- Shared pointer to the class
And.
◆ operator*() [1/2]
template<typename T , typename T2 , typename std::enable_if_t< std::is_convertible< T, std::size_t >::value > * = nullptr>
|
inline |
◆ operator*() [2/2]
◆ operator*=()
◆ operator+()
◆ operator+=()
◆ operator/() [1/2]
◆ operator/() [2/2]
◆ operator/=()
◆ operator<()
◆ operator<<() [1/24]
template<typename Scheme >
| std::ostream & helib::operator<< | ( | std::ostream & | is, |
| const Ptxt< Scheme > & | ptxt | ||
| ) |
Output shift operator. Uses the serialize function internally.
- Parameters
-
os Output std::ostream.ptxt Ptxtobject to be written.
- Returns
- Input
std::ostreampost writing.
- Note
Ptxtcontextis not serialized, see note ofoperator>>.
The output stream will be formatted as a comma-separated list surrounded by '[' and ']'.
Each slot of ptxt will be serialized in an element of such list by the serialize function determined by the scheme.
For example if we have a plaintext ptxt such that ptxt[0]=slot0, ptxt[1]=slot1, ptxt[2]=slot2, and ptxt[i]=0 for i>2, it will be serialized as '['slot0', 'slot1', 'slot2', 0, 0 ...]'.
◆ operator<<() [2/24]
| std::ostream& helib::operator<< | ( | std::ostream & | os, |
| const PolyMod & | poly | ||
| ) |
- Parameters
-
os Output std::ostream.poly PolyModobject to be written.
- Returns
- Input
std::ostreampost writing.
- 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 ']'.
Each coefficient of poly will be serialized in an element of such list by the >> operator.
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']'.
◆ operator<<() [3/24]
| std::ostream& helib::operator<< | ( | std::ostream & | os, |
| const PolyModRing & | ring | ||
| ) |
- Parameters
-
os Output std::ostream.ring PolyModRingobject to be written.
- Returns
- Input
std::ostreampost writing.
◆ operator<<() [4/24]
| std::ostream & helib::operator<< | ( | std::ostream & | s, |
| const ColPerm & | p | ||
| ) |
◆ operator<<() [5/24]
| std::ostream & helib::operator<< | ( | std::ostream & | s, |
| const CtxtPart & | p | ||
| ) |
◆ operator<<() [6/24]
|
inline |
◆ operator<<() [7/24]
| std::ostream& helib::operator<< | ( | std::ostream & | s, |
| const GeneratorTrees & | trees | ||
| ) |
◆ operator<<() [8/24]
| std::ostream& helib::operator<< | ( | std::ostream & | s, |
| const ModuliSizes & | szs | ||
| ) |
◆ operator<<() [9/24]
| std::ostream & helib::operator<< | ( | std::ostream & | s, |
| const ModuliSizes::Entry & | e | ||
| ) |
◆ operator<<() [10/24]
| std::ostream& helib::operator<< | ( | std::ostream & | s, |
| const PermNetwork & | net | ||
| ) |
◆ operator<<() [11/24]
|
inline |
◆ operator<<() [12/24]
|
inline |
◆ operator<<() [13/24]
| std::ostream& helib::operator<< | ( | std::ostream & | s, |
| const SubDimension & | sd | ||
| ) |
◆ operator<<() [14/24]
| std::ostream& helib::operator<< | ( | std::ostream & | s, |
| GenNodePtr | p | ||
| ) |
◆ operator<<() [15/24]
| std::ostream& helib::operator<< | ( | std::ostream & | s, |
| LongNodePtr | p | ||
| ) |
◆ operator<<() [16/24]
| std::ostream& helib::operator<< | ( | std::ostream & | s, |
| SplitNodePtr | p | ||
| ) |
◆ operator<<() [17/24]
template<typename T >
| std::ostream& helib::operator<< | ( | std::ostream & | s, |
| std::vector< T > | v | ||
| ) |
◆ operator<<() [18/24]
| std::ostream& helib::operator<< | ( | std::ostream & | str, |
| const Context & | context | ||
| ) |
◆ operator<<() [19/24]
| std::ostream& helib::operator<< | ( | std::ostream & | str, |
| const Ctxt & | ctxt | ||
| ) |
◆ operator<<() [20/24]
| std::ostream& helib::operator<< | ( | std::ostream & | str, |
| const DoubleCRT & | d | ||
| ) |
◆ operator<<() [21/24]
| std::ostream & helib::operator<< | ( | std::ostream & | str, |
| const IndexSet & | set | ||
| ) |
◆ operator<<() [22/24]
| std::ostream & helib::operator<< | ( | std::ostream & | str, |
| const KeySwitch & | matrix | ||
| ) |
◆ operator<<() [23/24]
| std::ostream& helib::operator<< | ( | std::ostream & | str, |
| const PubKey & | pk | ||
| ) |
◆ operator<<() [24/24]
| std::ostream& helib::operator<< | ( | std::ostream & | str, |
| const SecKey & | sk | ||
| ) |
◆ operator<<<BGV >()
◆ operator<<<CKKS >()
◆ operator<=()
◆ operator==()
template<typename T >
| bool helib::operator== | ( | const IndexMap< T > & | map1, |
| const IndexMap< T > & | map2 | ||
| ) |
Comparing maps, by comparing all the elements.
◆ operator>() [1/2]
◆ operator>() [2/2]
|
inline |
◆ operator>=()
◆ operator>>() [1/13]
| std::istream& helib::operator>> | ( | std::istream & | is, |
| PolyMod & | poly | ||
| ) |
- Parameters
-
is Input std::istream.poly Destination PolyModobject.
- Returns
- Input
std::istreampost reading.
- Note
polymust be constructed with an appropriate p2r and G BEFORE calling this function. For example,PolyMod my_poly(p2r, G);std::cin >> my_poly;
The input stream has to be formatted as a comma-separated list surrounded by '[' and ']'.
Each element of the list will be deserialized as a coefficient of the polynomial.
If the number of tokens in the list is less than the number of coefficients, the higher-degree coefficients will be padded by 0.
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.
◆ operator>>() [2/13]
template<typename Scheme >
| std::istream & helib::operator>> | ( | std::istream & | is, |
| Ptxt< Scheme > & | ptxt | ||
| ) |
Input shift operator. Uses the deserialize function internally.
- Parameters
-
is Input std::istream.ptxt Destination Ptxtobject.
- Returns
- Input
std::istreampost reading.
- Note
ptxtmust be constructed with an appropriate context BEFORE calling this function. For example,Ptxt my_ptxt(context);std::cin >> my_ptxt;
The input stream has to be formatted as a comma-separated list surrounded by '[' and ']'.
Each element of the list will be deserialized as a slot of the type determined by the scheme.
If the number of tokens in the list is less than the number of slots, the remaining slots will be padded by 0.
For example '['slot0', 'slot1', 'slot2']' will be deserialized as a plaintext ptxt where ptxt[0]=slot0, ptxt[1]=slot1, ptxt[2]=slot2 and ptxt[i]=0 for i>2.
◆ operator>>() [3/13]
| std::istream & helib::operator>> | ( | std::istream & | s, |
| CtxtPart & | p | ||
| ) |
◆ operator>>() [4/13]
| std::istream& helib::operator>> | ( | std::istream & | s, |
| ModuliSizes & | szs | ||
| ) |
◆ operator>>() [5/13]
| std::istream & helib::operator>> | ( | std::istream & | s, |
| ModuliSizes::Entry & | e | ||
| ) |
◆ operator>>() [6/13]
template<typename T >
| std::istream& helib::operator>> | ( | std::istream & | s, |
| std::vector< T > & | v | ||
| ) |
◆ operator>>() [7/13]
| std::istream& helib::operator>> | ( | std::istream & | str, |
| Context & | context | ||
| ) |
◆ operator>>() [8/13]
| std::istream& helib::operator>> | ( | std::istream & | str, |
| Ctxt & | ctxt | ||
| ) |
◆ operator>>() [9/13]
| std::istream& helib::operator>> | ( | std::istream & | str, |
| DoubleCRT & | d | ||
| ) |
◆ operator>>() [10/13]
| std::istream & helib::operator>> | ( | std::istream & | str, |
| IndexSet & | set | ||
| ) |
◆ operator>>() [11/13]
| std::istream& helib::operator>> | ( | std::istream & | str, |
| PubKey & | pk | ||
| ) |
◆ operator>>() [12/13]
| std::istream& helib::operator>> | ( | std::istream & | str, |
| SecKey & | sk | ||
| ) |
◆ operator>>() [13/13]
| std::istream& helib::operator>> | ( | std::istream & | str, |
| SKHandle & | handle | ||
| ) |
◆ operator>><BGV >()
◆ operator>><CKKS >()
◆ operator^()
◆ operator|()
◆ operator||()
Overloaded operator for creating a shared pointer to an OR expression.
- Parameters
-
lhs Left operand of the OR expression. rhs Right operand of the OR expression.
- Returns
- Shared pointer to the class
Or.
◆ optimalBenes()
| void helib::optimalBenes | ( | long | n, |
| long | budget, | ||
| bool | good, | ||
| long & | cost, | ||
| LongNodePtr & | solution | ||
| ) |
◆ optimalBenesAux()
| BenesMemoEntry helib::optimalBenesAux | ( | long | i, |
| long | budget, | ||
| long | nlev, | ||
| const NTL::Vec< NTL::Vec< long >> & | costTab, | ||
| BenesMemoTable & | memoTab | ||
| ) |
◆ optimalLower()
| LowerMemoEntry helib::optimalLower | ( | long | order, |
| bool | good, | ||
| long | budget, | ||
| long | mid, | ||
| LowerMemoTable & | lowerMemoTable | ||
| ) |
◆ optimalUpperAux()
| UpperMemoEntry helib::optimalUpperAux | ( | const NTL::Vec< GenDescriptor > & | vec, |
| long | i, | ||
| long | budget, | ||
| long | mid, | ||
| UpperMemoTable & | upperMemoTable, | ||
| LowerMemoTable & | lowerMemoTable | ||
| ) |
◆ ord()
| long helib::ord | ( | long | N, |
| long | p | ||
| ) |
Compute the highest power of p that divides N.
◆ packConstant()
| void helib::packConstant | ( | zzX & | result, |
| unsigned long | data, | ||
| long | nbits, | ||
| const EncryptedArray & | ea | ||
| ) |
◆ packConstants()
| void helib::packConstants | ( | zzX & | result, |
| const std::vector< std::size_t > & | data, | ||
| long | nbits, | ||
| const EncryptedArray & | ea | ||
| ) |
◆ packedRecrypt() [1/4]
| void helib::packedRecrypt | ( | const CtPtrMat & | m, |
| const std::vector< zzX > & | unpackConsts, | ||
| const EncryptedArray & | ea, | ||
| long | belowLvl = LONG_MAX |
||
| ) |
◆ packedRecrypt() [2/4]
| void helib::packedRecrypt | ( | const CtPtrs & | a, |
| const CtPtrs & | b, | ||
| std::vector< zzX > * | unpackSlotEncoding | ||
| ) |
Function for packed recryption to recrypt multiple numbers.
- Parameters
-
a first input of which to recrypt. b second input of which to recrypt. unpackSlotEncoding vector of constants for unpacking, as used in bootstrapping.
◆ packedRecrypt() [3/4]
| void helib::packedRecrypt | ( | const CtPtrs & | array, |
| const std::vector< zzX > & | unpackConsts, | ||
| const EncryptedArray & | ea, | ||
| long | belowLvl | ||
| ) |
◆ packedRecrypt() [4/4]
| void helib::packedRecrypt | ( | const CtPtrs & | cPtrs, |
| const std::vector< zzX > & | unpackConsts, | ||
| const EncryptedArray & | ea | ||
| ) |
◆ PAlgebraLift() [1/2]
template<>
| void helib::PAlgebraLift | ( | const NTL::ZZX & | phimx, |
| const NTL::vec_zz_pX & | lfactors, | ||
| NTL::vec_zz_pX & | factors, | ||
| NTL::vec_zz_pX & | crtc, | ||
| long | r | ||
| ) |
◆ PAlgebraLift() [2/2]
template<typename T >
| void helib::PAlgebraLift | ( | const NTL::ZZX & | phimx, |
| const T & | lfactors, | ||
| T & | factors, | ||
| T & | crtc, | ||
| long | r | ||
| ) |
◆ partialMatchEncode()
Given a value, encode the value across the coefficients of a polynomial.
- Parameters
-
input The value of which to encode. context The context object holding information on how to encode the value.
- Returns
- A polynomial representing the encoded value.
◆ phi_N()
| long helib::phi_N | ( | long | N | ) |
Compute Phi(N).
◆ phiN() [1/2]
| void helib::phiN | ( | long & | phiN, |
| std::vector< long > & | facts, | ||
| long | N | ||
| ) |
Compute Phi(N) and also factorize N.
◆ phiN() [2/2]
| void helib::phiN | ( | NTL::ZZ & | phiN, |
| std::vector< NTL::ZZ > & | facts, | ||
| const NTL::ZZ & | N | ||
| ) |
◆ plaintextAutomorph() [1/2]
template<typename RX , typename type >
| void helib::plaintextAutomorph | ( | RX & | b, |
| const RX & | a, | ||
| long | i, | ||
| long | j, | ||
| const EncryptedArrayDerived< type > & | ea | ||
| ) |
◆ plaintextAutomorph() [2/2]
template<typename RX , typename RXModulus >
| void helib::plaintextAutomorph | ( | RX & | bb, |
| const RX & | a, | ||
| long | k, | ||
| long | m, | ||
| const RXModulus & | PhimX | ||
| ) |
◆ plaintextAutomorph_CKKS()
| void helib::plaintextAutomorph_CKKS | ( | zzX & | b, |
| const zzX & | a, | ||
| long | j, | ||
| const EncryptedArrayCx & | ea | ||
| ) |
◆ poly_comp()
template<typename RX >
| bool helib::poly_comp | ( | const RX & | a, |
| const RX & | b | ||
| ) |
◆ polyEval() [1/2]
Evaluate an encrypted polynomial on an encrypted input.
- Parameters
-
[out] res to hold the return value [in] poly the degree-d polynomial to evaluate [in] x the point on which to evaluate
◆ polyEval() [2/2]
Evaluate a cleartext polynomial on an encrypted input.
- Parameters
-
[out] res to hold the return value [in] poly the degree-d polynomial to evaluate [in] x the point on which to evaluate [in] k optional optimization parameter, defaults to sqrt(d/2) rounded up or down to a power of two
◆ polyEvalMod()
| long helib::polyEvalMod | ( | const NTL::ZZX & | poly, |
| long | x, | ||
| long | p | ||
| ) |
Evaluates a modular integer polynomial, returns poly(x) mod p.
◆ PolyRed() [1/4]
|
inline |
◆ PolyRed() [2/4]
|
inline |
◆ PolyRed() [3/4]
| void helib::PolyRed | ( | NTL::ZZX & | out, |
| const NTL::ZZX & | in, | ||
| const NTL::ZZ & | q, | ||
| bool | abs = false |
||
| ) |
◆ PolyRed() [4/4]
| void helib::PolyRed | ( | NTL::ZZX & | out, |
| const NTL::ZZX & | in, | ||
| long | q, | ||
| bool | abs = false |
||
| ) |
Reduce all the coefficients of a polynomial modulo q.
When abs=false reduce to interval (-q/2,...,q/2), when abs=true reduce to [0,q). When abs=false and q=2, maintains the same sign as the input.
◆ power()
| void helib::power | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| long | e | ||
| ) |
◆ pp_factorize()
| void helib::pp_factorize | ( | std::vector< long > & | factors, |
| long | N | ||
| ) |
Prime-power factorization.
◆ ppInvert() [1/4]
|
inline |
◆ ppInvert() [2/4]
|
inline |
◆ ppInvert() [3/4]
| void helib::ppInvert | ( | NTL::mat_zz_p & | X, |
| const NTL::mat_zz_p & | A, | ||
| long | p, | ||
| long | r | ||
| ) |
Compute the inverse mod p^r of an n x n matrix.
NTL's current smallint modulus zz_p::modulus() is assumed to be p^r for p prime, r >= 1 integer. For the zz_pE variant also zz_pE::modulus() must be initialized. An error is raised if A is not invertible mod p.
◆ ppInvert() [4/4]
| void helib::ppInvert | ( | NTL::mat_zz_pE & | X, |
| const NTL::mat_zz_pE & | A, | ||
| long | p, | ||
| long | r | ||
| ) |
◆ ppsolve() [1/2]
| void helib::ppsolve | ( | NTL::vec_GF2E & | x, |
| const NTL::mat_GF2E & | A, | ||
| const NTL::vec_GF2E & | b, | ||
| long | p, | ||
| long | r | ||
| ) |
A version for GF2: must have p == 2 and r == 1.
◆ ppsolve() [2/2]
| void helib::ppsolve | ( | NTL::vec_zz_pE & | x, |
| const NTL::mat_zz_pE & | A, | ||
| const NTL::vec_zz_pE & | b, | ||
| long | p, | ||
| long | r | ||
| ) |
Prime power solver.
A is an n x n matrix, b is a length n (row) vector, this function finds a solution for the matrix-vector equation x A = b. An error is raised if A is not invertible mod p.
NTL's current smallint modulus, zz_p::modulus(), is assumed to be p^r, for p prime, r >= 1 integer.
◆ primroot()
| long helib::primroot | ( | long | N, |
| long | phiN | ||
| ) |
Find a primitive root modulo N.
◆ print() [1/2]
| void helib::print | ( | const EncryptedArray & | ea, |
| std::ostream & | s, | ||
| const PlaintextArray & | pa | ||
| ) |
◆ print() [2/2]
| void helib::print | ( | std::ostream & | s, |
| SplitNodePtr | p, | ||
| bool | first | ||
| ) |
◆ print3D() [1/3]
| template void helib::print3D | ( | const HyperCube< long > & | c | ) |
◆ print3D() [2/3]
| template void helib::print3D | ( | const HyperCube< NTL::zz_p > & | c | ) |
◆ print3D() [3/3]
template<typename T >
| void helib::print3D | ( | const HyperCube< T > & | c | ) |
◆ print_stats()
| void helib::print_stats | ( | std::ostream & | s | ) |
◆ printAllTimers()
| void helib::printAllTimers | ( | std::ostream & | str = std::cerr | ) |
Print the value of all timers to stream.
◆ printFlow()
| void helib::printFlow | ( | FlowGraph & | fg | ) |
◆ printMatrix()
template<typename T >
| void helib::printMatrix | ( | const Matrix< T > & | M, |
| std::ostream & | out = std::cout |
||
| ) |
◆ printNamedTimer()
| bool helib::printNamedTimer | ( | std::ostream & | str, |
| const char * | name | ||
| ) |
◆ printVec()
template<typename VEC >
| std::ostream& helib::printVec | ( | std::ostream & | s, |
| const VEC & | v, | ||
| long | nCoeffs = 40 |
||
| ) |
◆ printZZX()
|
inline |
◆ ptr2nonNull()
template<typename T >
| const T* helib::ptr2nonNull | ( | std::initializer_list< const PtrVector< T > * > | list | ) |
◆ random()
| void helib::random | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa | ||
| ) |
◆ randomPerm()
| void helib::randomPerm | ( | Permut & | perm, |
| long | n | ||
| ) |
A random size-n permutation.
◆ randomSlot()
template<typename Scheme >
| Scheme::SlotType helib::randomSlot | ( | const Context & | context | ) |
◆ randomSlot< BGV >()
template<>
| BGV::SlotType helib::randomSlot< BGV > | ( | const Context & | context | ) |
◆ randomSlot< CKKS >()
template<>
| CKKS::SlotType helib::randomSlot< CKKS > | ( | UNUSED const Context & | context | ) |
◆ RandPoly()
| NTL::ZZX helib::RandPoly | ( | long | n, |
| const NTL::ZZ & | p | ||
| ) |
◆ range() [1/2]
|
inline |
◆ range() [2/2]
|
inline |
◆ rationalApprox() [1/2]
| std::pair< long, long > helib::rationalApprox | ( | double | x, |
| long | denomBound = 0 |
||
| ) |
◆ rationalApprox() [2/2]
| std::pair< NTL::ZZ, NTL::ZZ > helib::rationalApprox | ( | NTL::xdouble | x, |
| NTL::xdouble | denomBound = NTL::xdouble(0.0) |
||
| ) |
◆ rawDecrypt()
| void helib::rawDecrypt | ( | NTL::ZZX & | plaintxt, |
| const std::vector< NTL::ZZX > & | zzParts, | ||
| const DoubleCRT & | sKey, | ||
| long | q = 0 |
||
| ) |
◆ read()
| void helib::read | ( | std::istream & | s, |
| ModuliSizes::Entry & | e | ||
| ) |
◆ read_ntl_vec_long()
| void helib::read_ntl_vec_long | ( | std::istream & | str, |
| NTL::vec_long & | vl | ||
| ) |
◆ read_raw_double()
| double helib::read_raw_double | ( | std::istream & | str | ) |
◆ read_raw_int()
| long helib::read_raw_int | ( | std::istream & | str | ) |
◆ read_raw_int32()
| int helib::read_raw_int32 | ( | std::istream & | str | ) |
◆ read_raw_vector() [1/3]
template<typename T >
| void helib::read_raw_vector | ( | std::istream & | str, |
| std::vector< T > & | v | ||
| ) |
◆ read_raw_vector() [2/3]
template<typename T >
| void helib::read_raw_vector | ( | std::istream & | str, |
| std::vector< T > & | v, | ||
| const Context & | context | ||
| ) |
◆ read_raw_vector() [3/3]
template<typename T >
| void helib::read_raw_vector | ( | std::istream & | str, |
| std::vector< T > & | v, | ||
| T & | init | ||
| ) |
◆ read_raw_vector< double >()
template<>
| void helib::read_raw_vector< double > | ( | std::istream & | str, |
| std::vector< double > & | v | ||
| ) |
◆ read_raw_vector< long >()
template<>
| void helib::read_raw_vector< long > | ( | std::istream & | str, |
| std::vector< long > & | v | ||
| ) |
◆ read_raw_xdouble()
| NTL::xdouble helib::read_raw_xdouble | ( | std::istream & | str | ) |
◆ read_raw_ZZ()
| void helib::read_raw_ZZ | ( | std::istream & | str, |
| NTL::ZZ & | zz | ||
| ) |
◆ readContextBase()
| void helib::readContextBase | ( | std::istream & | s, |
| unsigned long & | m, | ||
| unsigned long & | p, | ||
| unsigned long & | r, | ||
| std::vector< long > & | gens, | ||
| std::vector< long > & | ords | ||
| ) |
read [m p r gens ords] data, needed to construct context
read [m p r] data, needed to construct context
◆ readContextBaseBinary()
| void helib::readContextBaseBinary | ( | std::istream & | s, |
| unsigned long & | m, | ||
| unsigned long & | p, | ||
| unsigned long & | r, | ||
| std::vector< long > & | gens, | ||
| std::vector< long > & | ords | ||
| ) |
read [m p r gens ords] data, needed to construct context
◆ readContextBinary()
| void helib::readContextBinary | ( | std::istream & | str, |
| Context & | context | ||
| ) |
◆ readEyeCatcher()
| int helib::readEyeCatcher | ( | std::istream & | str, |
| const char * | expect | ||
| ) |
◆ readPubKeyBinary()
| void helib::readPubKeyBinary | ( | std::istream & | str, |
| PubKey & | pk | ||
| ) |
◆ readSecKeyBinary()
| void helib::readSecKeyBinary | ( | std::istream & | str, |
| SecKey & | sk | ||
| ) |
◆ realToEstimatedNoise()
◆ recordAutomorphVal()
|
inline |
◆ recordAutomorphVal2()
|
inline |
◆ reducedCount()
| long helib::reducedCount | ( | const std::list< long > & | x, |
| long | n, | ||
| bool * | aux | ||
| ) |
◆ reduceModPhimX()
◆ registerTimer()
| void helib::registerTimer | ( | FHEtimer * | timer | ) |
◆ RelaxedInv() [1/2]
| void helib::RelaxedInv | ( | NTL::Mat< NTL::GF2 > & | x, |
| const NTL::Mat< NTL::GF2 > & | a | ||
| ) |
◆ RelaxedInv() [2/2]
| void helib::RelaxedInv | ( | NTL::Mat< NTL::zz_p > & | x, |
| const NTL::Mat< NTL::zz_p > & | a | ||
| ) |
◆ rem()
| void helib::rem | ( | NTL::zz_pX & | r, |
| const NTL::zz_pX & | a, | ||
| const zz_pXModulus1 & | ff | ||
| ) |
◆ removeDups()
| void helib::removeDups | ( | std::list< long > & | x, |
| bool * | aux | ||
| ) |
◆ repack() [1/2]
| long helib::repack | ( | const CtPtrs & | packed, |
| const CtPtrs & | unpacked, | ||
| const EncryptedArray & | ea | ||
| ) |
◆ repack() [2/2]
| void helib::repack | ( | Ctxt & | packed, |
| const CtPtrs & | unpacked, | ||
| const EncryptedArray & | ea | ||
| ) |
◆ replicate() [1/3]
template<typename Scheme >
| void helib::replicate | ( | const EncryptedArray & | , |
| Ptxt< Scheme > & | ptxt, | ||
| long | i | ||
| ) |
◆ replicate() [2/3]
| void helib::replicate | ( | const EncryptedArray & | ea, |
| Ctxt & | ctx, | ||
| long | pos | ||
| ) |
The value in slot #pos is replicated in all other slots. On an n-slot ciphertext, this algorithm performs O(log n) 1D rotations.
◆ replicate() [3/3]
| void helib::replicate | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| long | i | ||
| ) |
◆ replicate0()
| void helib::replicate0 | ( | const EncryptedArray & | ea, |
| Ctxt & | ctxt, | ||
| long | pos | ||
| ) |
A lower-level routine. Same as replicate, but assumes all slots are zero except slot #pos.
◆ replicateAll() [1/3]
| void helib::replicateAll | ( | const EncryptedArray & | ea, |
| const Ctxt & | ctxt, | ||
| ReplicateHandler * | handler, | ||
| long | recBound = 64, |
||
| RepAuxDim * | repAuxPtr = nullptr |
||
| ) |
replicateAll uses a hybrid strategy, combining the O(log n) strategy of the replicate method, with an O(1) strategy, which is faster but introduces more noise. This tradeoff is controlled by the parameter recBound:
- recBound < 0: recursion to depth |recBound| (faster, noisier)
- recBound ==0: no recursion (slower, less noise)
- recBound > 0: the recursion depth is chosen heuristically, but is capped at recBound
The default value for recBound is 64, this ensures that the choice is based only on the heuristic, which will introduce noise corresponding to O(log log n) levels of recursion, but still gives an algorithm that theoretically runs in time O(n).
◆ replicateAll() [2/3]
| void helib::replicateAll | ( | std::vector< Ctxt > & | v, |
| const EncryptedArray & | ea, | ||
| const Ctxt & | ctxt, | ||
| long | recBound = 64, |
||
| RepAuxDim * | repAuxPtr = nullptr |
||
| ) |
return the result as a std::vector of ciphertexts, mostly useful for debugging purposes (for real parameters would take a lot of memory)
◆ replicateAll() [3/3]
template<typename Scheme >
| void helib::replicateAll | ( | std::vector< Ptxt< Scheme >> & | v, |
| const EncryptedArray & | , | ||
| const Ptxt< Scheme > & | ptxt | ||
| ) |
Generate a vector of plaintexts with each slot replicated in each plaintext.
- Parameters
-
v Vector of replicated plaintext slots. ptxt Plaintext whose slots will be replicated.
The order of the return vector agrees with the order of the slots. i.e. the ith plaintext in the return value is a replication of *this[i].
◆ replicateAllOrig()
| void helib::replicateAllOrig | ( | const EncryptedArray & | ea, |
| const Ctxt & | ctxt, | ||
| ReplicateHandler * | handler, | ||
| RepAux * | repAuxPtr = nullptr |
||
| ) |
This function is obsolete, and is kept for historical purposes only. It was a first attempt at implementing the O(1)-amortized algorithm, but is less efficient than the function above.
◆ resetAllTimers()
| void helib::resetAllTimers | ( | ) |
◆ resize() [1/7]
template<typename T >
| void helib::resize | ( | NTL::Vec< T > & | v, |
| long | sz | ||
| ) |
◆ resize() [2/7]
template<typename T >
| void helib::resize | ( | NTL::Vec< T > & | v, |
| long | sz, | ||
| const T & | val | ||
| ) |
◆ resize() [3/7]
template<typename T >
| void helib::resize | ( | PtrMatrix< T > & | v, |
| long | newSize | ||
| ) |
◆ resize() [4/7]
template<typename T >
| void helib::resize | ( | PtrVector< T > & | v, |
| long | newSize, | ||
| const T & | val | ||
| ) |
◆ resize() [5/7]
template<typename T >
| void helib::resize | ( | PtrVector< T > & | v, |
| long | newSize, | ||
| const T * | val | ||
| ) |
◆ resize() [6/7]
template<typename T >
| void helib::resize | ( | std::vector< T > & | v, |
| long | sz | ||
| ) |
◆ resize() [7/7]
template<typename T >
| void helib::resize | ( | std::vector< T > & | v, |
| long | sz, | ||
| const T & | val | ||
| ) |
◆ reverse()
template<typename T >
| void helib::reverse | ( | NTL::Vec< T > & | v, |
| long | lo, | ||
| long | hi | ||
| ) |
Reverse a vector in place.
◆ RLWE()
| double helib::RLWE | ( | DoubleCRT & | c0, |
| DoubleCRT & | c1, | ||
| const DoubleCRT & | s, | ||
| long | p, | ||
| NTL::ZZ * | prgSeed = nullptr |
||
| ) |
Choose random c0,c1 such that c0+s*c1 = p*e for a short e Returns a high-probability bound on the L-infty norm of the canonical embedding
◆ RLWE1()
Same as RLWE, but assumes that c1 is already chosen by the caller.
◆ rotate() [1/2]
| void helib::rotate | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| long | k | ||
| ) |
◆ rotate() [2/2]
template<typename T >
| void helib::rotate | ( | NTL::Vec< T > & | v, |
| long | k | ||
| ) |
Rotate a vector in place using swaps.
◆ runningSums() [1/2]
| void helib::runningSums | ( | const EncryptedArray & | ea, |
| Ctxt & | ctxt | ||
| ) |
A ctxt that encrypts is replaced by an encryption of , where .
◆ runningSums() [2/2]
| void helib::runningSums | ( | CtPtrs & | v | ) |
◆ sameObject()
template<typename T1 , typename T2 >
| bool helib::sameObject | ( | const T1 * | p1, |
| const T2 * | p2 | ||
| ) |
Testing if two vectors point to the same object.
◆ sampleGaussian() [1/4]
| void helib::sampleGaussian | ( | NTL::ZZX & | poly, |
| long | n, | ||
| double | stdev | ||
| ) |
◆ sampleGaussian() [2/4]
| void helib::sampleGaussian | ( | std::vector< double > & | dvec, |
| long | n, | ||
| double | stdev | ||
| ) |
Choose a vector of continuous Gaussians.
◆ sampleGaussian() [3/4]
◆ sampleGaussian() [4/4]
| void helib::sampleGaussian | ( | zzX & | poly, |
| long | n, | ||
| double | stdev | ||
| ) |
Sample polynomials with Gaussian coefficients.
◆ sampleGaussianBounded()
◆ sampleHWt() [1/3]
| void helib::sampleHWt | ( | NTL::ZZX & | poly, |
| long | n, | ||
| long | Hwt = 100 |
||
| ) |
◆ sampleHWt() [2/3]
◆ sampleHWt() [3/3]
| void helib::sampleHWt | ( | zzX & | poly, |
| long | n, | ||
| long | Hwt = 100 |
||
| ) |
Sample a degree-(n-1) poly as above, with only Hwt nonzero coefficients.
◆ sampleHWtBounded()
◆ sampleHWtBoundedEffectiveBound()
| double helib::sampleHWtBoundedEffectiveBound | ( | const Context & | context, |
| long | Hwt = 100 |
||
| ) |
◆ sampleSmall() [1/3]
| void helib::sampleSmall | ( | NTL::ZZX & | poly, |
| long | n, | ||
| double | prob = 0.5 |
||
| ) |
◆ sampleSmall() [2/3]
◆ sampleSmall() [3/3]
| void helib::sampleSmall | ( | zzX & | poly, |
| long | n, | ||
| double | prob = 0.5 |
||
| ) |
Sample a degree-(n-1) poly, with -1/0/+1 coefficients. Each coefficients is +-1 with probability prob/2 each, and 0 with probability 1-prob. By default, pr[nonzero]=1/2.
◆ sampleSmallBounded()
◆ sampleUniform() [1/4]
| NTL::xdouble helib::sampleUniform | ( | NTL::ZZX & | poly, |
| const Context & | context, | ||
| const NTL::ZZ & | B = NTL::ZZ(100L) |
||
| ) |
◆ sampleUniform() [2/4]
| void helib::sampleUniform | ( | NTL::ZZX & | poly, |
| long | n, | ||
| const NTL::ZZ & | B = NTL::ZZ(100L) |
||
| ) |
◆ sampleUniform() [3/4]
◆ sampleUniform() [4/4]
| void helib::sampleUniform | ( | zzX & | poly, |
| long | n, | ||
| long | B = 100 |
||
| ) |
Sample a degree-(n-1) ZZX, with coefficients uniform in [-B,B].
◆ seekPastChar()
| void helib::seekPastChar | ( | std::istream & | str, |
| int | cc | ||
| ) |
Advance the input stream beyond white spaces and a single instance of the char cc.
◆ serialize() [1/3]
| void helib::serialize | ( | std::ostream & | os, |
| const PolyMod & | poly | ||
| ) |
- Parameters
-
os Output std::ostream.poly PolyModobject to be written.
- Returns
- Input
std::ostreampost 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 ']'.
Each coefficient of poly will be serialized in an element of such list by the >> operator.
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']'.
◆ serialize() [2/3]
template<typename Scheme >
| void helib::serialize | ( | std::ostream & | os, |
| const Ptxt< Scheme > & | ptxt | ||
| ) |
Function to serialize a Ptxt<Scheme>.
- Parameters
-
os Output std::ostream.ptxt Ptxtobject to be written.
- Returns
- Input
std::ostreampost serializing.
- Note
Ptxtcontextis not serialized, see note ofdeserialize.
The output stream will be formatted as a comma-separated list surrounded by '[' and ']'.
Each slot of ptxt will be serialized in an element of such list by the serialize function determined by the scheme.
For example if we have a plaintext ptxt such that ptxt[0]=slot0, ptxt[1]=slot1, ptxt[2]=slot2, and ptxt[i]=0 for i>2, it will be serialized as '['slot0', 'slot1', 'slot2', 0, 0 ...]'.
◆ serialize() [3/3]
| void helib::serialize | ( | std::ostream & | os, |
| const std::complex< double > & | num | ||
| ) |
Serialize a std::complex<double> to the output stream os delimited by '[' and ']' (instead of the default '(', ')').
- Parameters
-
os The output stream reference. num The complex number to serialize.
The output will be formatted as '['num.real()', 'num.imag()']'.
◆ serialize< BGV >()
| template void helib::serialize< BGV > | ( | std::ostream & | os, |
| const Ptxt< BGV > & | ptxt | ||
| ) |
◆ serialize< CKKS >()
| template void helib::serialize< CKKS > | ( | std::ostream & | os, |
| const Ptxt< CKKS > & | ptxt | ||
| ) |
◆ setAutomorphVals()
|
inline |
◆ setAutomorphVals2()
|
inline |
◆ setDryRun()
|
inline |
◆ setHyperColumn() [1/6]
| template void helib::setHyperColumn | ( | const NTL::Vec< long > & | v, |
| const CubeSlice< long > & | s, | ||
| long | pos | ||
| ) |
◆ setHyperColumn() [2/6]
| template void helib::setHyperColumn | ( | const NTL::Vec< long > & | v, |
| const CubeSlice< long > & | s, | ||
| long | pos, | ||
| const long & | val | ||
| ) |
◆ setHyperColumn() [3/6]
| template void helib::setHyperColumn | ( | const NTL::Vec< NTL::zz_p > & | v, |
| const CubeSlice< NTL::zz_p > & | s, | ||
| long | pos | ||
| ) |
◆ setHyperColumn() [4/6]
| template void helib::setHyperColumn | ( | const NTL::Vec< NTL::zz_p > & | v, |
| const CubeSlice< NTL::zz_p > & | s, | ||
| long | pos, | ||
| const NTL::zz_p & | val | ||
| ) |
◆ setHyperColumn() [5/6]
template<typename T >
| void helib::setHyperColumn | ( | const NTL::Vec< T > & | v, |
| const CubeSlice< T > & | s, | ||
| long | pos | ||
| ) |
setHyperColumn does the reverse of getHyperColumn, setting the column to the given vector
◆ setHyperColumn() [6/6]
template<typename T >
| void helib::setHyperColumn | ( | const NTL::Vec< T > & | v, |
| const CubeSlice< T > & | s, | ||
| long | pos, | ||
| const T & | val | ||
| ) |
this version of setHyperColumn implicitly pads v with a default value, if v is too short
◆ setLengthZero() [1/4]
template<typename T >
| void helib::setLengthZero | ( | NTL::Vec< T > & | vec | ) |
◆ setLengthZero() [2/4]
template<typename T >
| void helib::setLengthZero | ( | PtrMatrix< T > & | v | ) |
◆ setLengthZero() [3/4]
template<typename T >
| void helib::setLengthZero | ( | PtrVector< T > & | v | ) |
◆ setLengthZero() [4/4]
template<typename T >
| void helib::setLengthZero | ( | std::vector< T > & | vec | ) |
◆ setTimersOff()
|
inline |
◆ setTimersOn()
|
inline |
◆ setupDebugGlobals()
|
inline |
Setup function for setting up the global debug variables.
- Note
- Works only if
HELIB_DEBUGis defined. It does not do anything otherwise
◆ shift()
| void helib::shift | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| long | k | ||
| ) |
◆ splitBinaryNums()
Splits a single binary number into two binary numbers leftSplit and rightSplit.
Split a binary number into two separate binary numbers.
- Parameters
-
leftSplit Left hand side of the split. rightSplit Right hand side of the split. input Binary number to be split.
- Note
- The size of
leftSplitandrightSplitmust sum to the size ofinput. -
The location of the split is defined by the sizes of
leftSplitandrightSplit.
◆ sub()
| void helib::sub | ( | const EncryptedArray & | ea, |
| PlaintextArray & | pa, | ||
| const PlaintextArray & | other | ||
| ) |
◆ subtractBinary()
| void helib::subtractBinary | ( | CtPtrs & | difference, |
| const CtPtrs & | lhs, | ||
| const CtPtrs & | rhs, | ||
| std::vector< zzX > * | unpackSlotEncoding = nullptr |
||
| ) |
Subtracts rhs from lhs where lhs, rhs are in 2's complement.
- Parameters
-
difference Reference to the difference post subtraction. lhs Left hand side of subtraction. rhs Right hand side of subtraction. unpackSlotEncoding vector of constants for unpacking, as used in bootstrapping.
- Note
lhsandrhsmust have the same size.
◆ sumOfCoeffs() [1/3]
| NTL::ZZ helib::sumOfCoeffs | ( | const DoubleCRT & | f | ) |
◆ sumOfCoeffs() [2/3]
| NTL::ZZ helib::sumOfCoeffs | ( | const NTL::ZZX & | f | ) |
◆ sumOfCoeffs() [3/3]
| long helib::sumOfCoeffs | ( | const zzX & | f | ) |
◆ swap() [1/2]
template<typename X , typename Cloner >
| void helib::swap | ( | cloned_ptr< X, Cloner > & | x, |
| cloned_ptr< X, Cloner > & | y | ||
| ) |
◆ swap() [2/2]
template<typename X , typename Cloner >
| void helib::swap | ( | copied_ptr< X, Cloner > & | x, |
| copied_ptr< X, Cloner > & | y | ||
| ) |
◆ tableLookup()
| void helib::tableLookup | ( | Ctxt & | out, |
| const std::vector< zzX > & | table, | ||
| const CtPtrs & | idx, | ||
| std::vector< zzX > * | unpackSlotEncoding = nullptr |
||
| ) |
The input is a plaintext table T[] and an array of encrypted bits I[], holding the binary representation of an index i into T. The output is the encrypted value T[i].
◆ tableWriteIn()
| void helib::tableWriteIn | ( | const CtPtrs & | table, |
| const CtPtrs & | idx, | ||
| std::vector< zzX > * | unpackSlotEncoding = nullptr |
||
| ) |
The input is an encrypted table T[] and an array of encrypted bits I[], holding the binary representation of an index i into T. This function increments by one the entry T[i].
◆ timer_compare()
◆ to_ZZX()
|
inline |
◆ TofftRep_trunc() [1/2]
|
inline |
◆ TofftRep_trunc() [2/2]
|
inline |
◆ totalProduct()
◆ totalSums()
| void helib::totalSums | ( | const EncryptedArray & | ea, |
| Ctxt & | ctxt | ||
| ) |
◆ traceMap()
| void helib::traceMap | ( | Ctxt & | ctxt | ) |
◆ TraceMap()
| void helib::TraceMap | ( | NTL::GF2X & | w, |
| const NTL::GF2X & | a, | ||
| long | d, | ||
| const NTL::GF2XModulus & | F, | ||
| const NTL::GF2X & | b | ||
| ) |
◆ unpack() [1/2]
| long helib::unpack | ( | const CtPtrs & | unpacked, |
| const CtPtrs & | packed, | ||
| const EncryptedArray & | ea, | ||
| const std::vector< zzX > & | unpackSlotEncoding | ||
| ) |
◆ unpack() [2/2]
| void helib::unpack | ( | const CtPtrs & | unpacked, |
| const Ctxt & | packed, | ||
| const EncryptedArray & | ea, | ||
| const std::vector< zzX > & | unpackSlotEncoding | ||
| ) |
◆ unpackSlots() [1/2]
|
inline |
◆ unpackSlots() [2/2]
| void helib::unpackSlots | ( | std::vector< std::size_t > & | value, |
| PlaintextArray & | pa, | ||
| const EncryptedArray & | ea | ||
| ) |
◆ Vec_replicate()
template<typename T >
| std::vector<T> helib::Vec_replicate | ( | const T & | a, |
| long | n | ||
| ) |
◆ vecCopy() [1/4]
template<typename T >
| void helib::vecCopy | ( | PtrVector< T > & | v1, |
| const PtrVector< T > & | v2, | ||
| long | sizeLimit = 0 |
||
| ) |
◆ vecCopy() [2/4]
template<typename V , typename T >
| void helib::vecCopy | ( | PtrVector< T > & | v1, |
| const V & | v2, | ||
| long | sizeLimit = 0 |
||
| ) |
◆ vecCopy() [3/4]
template<typename V , typename T >
| void helib::vecCopy | ( | V & | v1, |
| const PtrVector< T > & | v2, | ||
| long | sizeLimit = 0 |
||
| ) |
◆ vecCopy() [4/4]
template<typename V1 , typename V2 >
| void helib::vecCopy | ( | V1 & | v1, |
| const V2 & | v2, | ||
| long | sizeLimit = 0 |
||
| ) |
◆ vecRed() [1/2]
| void helib::vecRed | ( | NTL::Vec< NTL::ZZ > & | out, |
| const NTL::Vec< NTL::ZZ > & | in, | ||
| const NTL::ZZ & | q, | ||
| bool | abs | ||
| ) |
◆ vecRed() [2/2]
| void helib::vecRed | ( | NTL::Vec< NTL::ZZ > & | out, |
| const NTL::Vec< NTL::ZZ > & | in, | ||
| long | q, | ||
| bool | abs | ||
| ) |
◆ vector_replicate()
template<typename T >
| std::vector<T> helib::vector_replicate | ( | const T & | a, |
| long | n | ||
| ) |
◆ vecToStr()
template<typename T >
| std::string helib::vecToStr | ( | const std::vector< T > & | v | ) |
◆ Warning() [1/2]
|
inline |
Function for logging a warning message.
- Parameters
-
msg The warning message.
◆ Warning() [2/2]
|
inline |
Function for logging a warning message.
- Parameters
-
msg The warning message.
◆ write()
| void helib::write | ( | std::ostream & | s, |
| const ModuliSizes::Entry & | e | ||
| ) |
◆ write_ntl_vec_long()
| void helib::write_ntl_vec_long | ( | std::ostream & | str, |
| const NTL::vec_long & | vl, | ||
| long | intSize = BINIO_64BIT |
||
| ) |
◆ write_raw_double()
| void helib::write_raw_double | ( | std::ostream & | str, |
| const double | d | ||
| ) |
◆ write_raw_int()
| void helib::write_raw_int | ( | std::ostream & | str, |
| long | num | ||
| ) |
◆ write_raw_int32()
| void helib::write_raw_int32 | ( | std::ostream & | str, |
| int | num | ||
| ) |
◆ write_raw_vector()
template<typename T >
| void helib::write_raw_vector | ( | std::ostream & | str, |
| const std::vector< T > & | v | ||
| ) |
◆ write_raw_vector< double >()
template<>
| void helib::write_raw_vector< double > | ( | std::ostream & | str, |
| const std::vector< double > & | v | ||
| ) |
◆ write_raw_vector< long >()
template<>
| void helib::write_raw_vector< long > | ( | std::ostream & | str, |
| const std::vector< long > & | v | ||
| ) |
◆ write_raw_xdouble()
| void helib::write_raw_xdouble | ( | std::ostream & | str, |
| const NTL::xdouble | xd | ||
| ) |
◆ write_raw_ZZ()
| void helib::write_raw_ZZ | ( | std::ostream & | str, |
| const NTL::ZZ & | zz | ||
| ) |
◆ writeContextBase()
| void helib::writeContextBase | ( | std::ostream & | s, |
| const Context & | context | ||
| ) |
write [m p r gens ords] data
write [m p r] data
◆ writeContextBaseBinary()
| void helib::writeContextBaseBinary | ( | std::ostream & | str, |
| const Context & | context | ||
| ) |
write [m p r gens ords] data
◆ writeContextBinary()
| void helib::writeContextBinary | ( | std::ostream & | str, |
| const Context & | context | ||
| ) |
◆ writeEyeCatcher()
| void helib::writeEyeCatcher | ( | std::ostream & | str, |
| const char * | eye | ||
| ) |
◆ writePubKeyBinary()
| void helib::writePubKeyBinary | ( | std::ostream & | str, |
| const PubKey & | pk | ||
| ) |
◆ writeSecKeyBinary()
| void helib::writeSecKeyBinary | ( | std::ostream & | str, |
| const SecKey & | sk | ||
| ) |
◆ zeroValue()
template<typename T >
|
inline |
Given an object x return a zero object of the same type.
- Template Parameters
-
T Type of object to return.
- Parameters
-
x The object to use for returning a zero object of type T.
- Returns
- A zero object of type
T.
◆ zeroValue< Ctxt >()
template<>
|
inline |
◆ zeroValue< Ptxt< BGV > >()
◆ zeroValue< Ptxt< CKKS > >()
Variable Documentation
◆ activeContext
| Context * helib::activeContext = nullptr |
◆ CLOCK_SCALE
| const unsigned long helib::CLOCK_SCALE = (unsigned long)CLOCKS_PER_SEC |
◆ dbg_ptxt
| NTL::ZZX helib::dbg_ptxt |
◆ dbgEa
| std::shared_ptr< const EncryptedArray > helib::dbgEa = nullptr |
◆ dbgKey
| SecKey * helib::dbgKey = nullptr |
◆ erfc_inverse
| const double helib::erfc_inverse[] |
Initial value:
= {0,
0.6744897501960817432,
1.1503493803760081782,
1.5341205443525463117,
1.8627318674216514554,
2.1538746940614562129,
2.4175590162365050618,
2.6600674686174596585,
2.8856349124267571473,
3.0972690781987844623,
3.2971933456919633418,
3.4871041041144311068,
3.6683292851213230192,
3.8419306855019108708,
4.0087725941685849622,
4.1695693233491057549,
4.3249190408260462571,
4.4753284246542033544,
4.6212310014992471565,
4.7630010342678139569,
4.9009642079631930118}
◆ fhe_force_chen_han
| long helib::fhe_force_chen_han = 0 |
◆ fhe_stats
| bool helib::fhe_stats = false |
◆ fhe_test_force_bsgs
| int helib::fhe_test_force_bsgs = 0 |
◆ fhe_test_force_hoist
| int helib::fhe_test_force_hoist = 0 |
◆ fhe_watcher
| int helib::fhe_watcher = 0 |
◆ helog
| Logger helib::helog |
Initial value:
Internal global logger.
◆ PI
| const long double helib::PI |
Initial value:
=
3.1415926535897932384626433832795028841971693993751058209749445923078164L
◆ printFlag
|
extern |
◆ replicateVerboseFlag
| NTL_THREAD_LOCAL bool helib::replicateVerboseFlag = false |
◆ thinRecrypt_initial_level
|
extern |
void deserialize(std::istream &is, std::complex< double > &num)
Deserialize a std::complex<double> from the input stream is delimited by '[' and ']' (instead of the ...
Definition: Ptxt.cpp:19
void setLogToFile(const std::string &filepath, bool overwrite=false)
Set the logger object to write to specified file.
Definition: log.cpp:49
