Renaming non-member functions

examples/function_evaluation.rs

@@ -19,7 +19,7 @@ fn EvalLogisticExample()
     let _mult_depth: u32 = 6;
     _cc_params_ckksrns.pin_mut().SetMultiplicativeDepth(_mult_depth);
 
-    let _cc = ffi::GenCryptoContextByParamsCKKSRNS(&_cc_params_ckksrns);
+    let _cc = ffi::DCRTPolyGenCryptoContextByParamsCKKSRNS(&_cc_params_ckksrns);
     _cc.Enable(ffi::PKESchemeFeature::PKE);
     _cc.Enable(ffi::PKESchemeFeature::KEYSWITCH);
     _cc.Enable(ffi::PKESchemeFeature::LEVELEDSHE);
@@ -39,7 +39,7 @@ fn EvalLogisticExample()
     _input.pin_mut().push(ffi::ComplexPair{re: 3.0, im: 0.0});
     _input.pin_mut().push(ffi::ComplexPair{re: 4.0, im: 0.0});
     let _encoded_length: usize = _input.len();
-    let _dcrt_poly_params = ffi::GenNullDCRTPolyParams();
+    let _dcrt_poly_params = ffi::DCRTPolyGenNullParams();
     let _plain_text = _cc.MakeCKKSPackedPlaintextByVectorOfComplex(&_input, 1, 0, &_dcrt_poly_params, 0);
     let _cipher_text = _cc.EncryptByPublicKey(&_key_pair.GetPublicKey(), &_plain_text);
     let _lower_bound: f64 = -5.0;
@@ -88,7 +88,7 @@ fn EvalFunctionExample()
     let _mult_depth: u32 = 7;
     _cc_params_ckksrns.pin_mut().SetMultiplicativeDepth(_mult_depth);
 
-    let _cc = ffi::GenCryptoContextByParamsCKKSRNS(&_cc_params_ckksrns);
+    let _cc = ffi::DCRTPolyGenCryptoContextByParamsCKKSRNS(&_cc_params_ckksrns);
     _cc.Enable(ffi::PKESchemeFeature::PKE);
     _cc.Enable(ffi::PKESchemeFeature::KEYSWITCH);
     _cc.Enable(ffi::PKESchemeFeature::LEVELEDSHE);
@@ -108,7 +108,7 @@ fn EvalFunctionExample()
     _input.pin_mut().push(ffi::ComplexPair{re: 9.0, im: 0.0});
 
     let _encoded_length: usize = _input.len();
-    let _dcrt_poly_params = ffi::GenNullDCRTPolyParams();
+    let _dcrt_poly_params = ffi::DCRTPolyGenNullParams();
     let _plain_text = _cc.MakeCKKSPackedPlaintextByVectorOfComplex(&_input, 1, 0, &_dcrt_poly_params, 0);
     let _cipher_text = _cc.EncryptByPublicKey(&_key_pair.GetPublicKey(), &_plain_text);
     let _lower_bound: f64 = 0.0;

examples/polynomial_evaluation.rs

@@ -10,7 +10,7 @@ fn main()
     _cc_params_ckksrns.pin_mut().SetMultiplicativeDepth(6);
     _cc_params_ckksrns.pin_mut().SetScalingModSize(50);
 
-    let _cc = ffi::GenCryptoContextByParamsCKKSRNS(&_cc_params_ckksrns);
+    let _cc = ffi::DCRTPolyGenCryptoContextByParamsCKKSRNS(&_cc_params_ckksrns);
     _cc.Enable(ffi::PKESchemeFeature::PKE);
     _cc.Enable(ffi::PKESchemeFeature::KEYSWITCH);
     _cc.Enable(ffi::PKESchemeFeature::LEVELEDSHE);
@@ -75,7 +75,7 @@ fn main()
     _coefficients_2.pin_mut().push(-0.4);
     _coefficients_2.pin_mut().push(-0.5);
 
-    let _dcrt_poly_params = ffi::GenNullDCRTPolyParams();
+    let _dcrt_poly_params = ffi::DCRTPolyGenNullParams();
     let _plain_text_1 = _cc.MakeCKKSPackedPlaintextByVectorOfComplex(&_input, 1, 0, &_dcrt_poly_params, 0);
     let _key_pair = _cc.KeyGen();
     print!("Generating evaluation key for homomorphic multiplication...");

examples/simple_integers.rs

@@ -7,7 +7,7 @@ fn main()
     _cc_params_bfvrns.pin_mut().SetPlaintextModulus(65537);
     _cc_params_bfvrns.pin_mut().SetMultiplicativeDepth(2);
 
-    let _cc = ffi::GenCryptoContextByParamsBFVRNS(&_cc_params_bfvrns);
+    let _cc = ffi::DCRTPolyGenCryptoContextByParamsBFVRNS(&_cc_params_bfvrns);
     _cc.Enable(ffi::PKESchemeFeature::PKE);
     _cc.Enable(ffi::PKESchemeFeature::KEYSWITCH);
     _cc.Enable(ffi::PKESchemeFeature::LEVELEDSHE);
@@ -20,7 +20,7 @@ fn main()
     _index_list.pin_mut().push(2);
     _index_list.pin_mut().push(-1);
     _index_list.pin_mut().push(-2);
-    _cc.EvalRotateKeyGen(&_key_pair.GetPrivateKey(), &_index_list, &ffi::GenNullPublicKey());
+    _cc.EvalRotateKeyGen(&_key_pair.GetPrivateKey(), &_index_list, &ffi::DCRTPolyGenNullPublicKey());
 
     let mut _vector_of_ints_1 = CxxVector::<i64>::new();
     _vector_of_ints_1.pin_mut().push(1);

examples/simple_real_numbers.rs

@@ -12,7 +12,7 @@ fn main()
     _cc_params_ckksrns.pin_mut().SetScalingModSize(_scale_mod_size);
     _cc_params_ckksrns.pin_mut().SetBatchSize(_batch_size);
 
-    let _cc = ffi::GenCryptoContextByParamsCKKSRNS(&_cc_params_ckksrns);
+    let _cc = ffi::DCRTPolyGenCryptoContextByParamsCKKSRNS(&_cc_params_ckksrns);
     _cc.Enable(ffi::PKESchemeFeature::PKE);
     _cc.Enable(ffi::PKESchemeFeature::KEYSWITCH);
     _cc.Enable(ffi::PKESchemeFeature::LEVELEDSHE);
@@ -24,7 +24,7 @@ fn main()
     let mut _index_list = CxxVector::<i32>::new();
     _index_list.pin_mut().push(1);
     _index_list.pin_mut().push(-2);
-    _cc.EvalRotateKeyGen(&_key_pair.GetPrivateKey(), &_index_list, &ffi::GenNullPublicKey());
+    _cc.EvalRotateKeyGen(&_key_pair.GetPrivateKey(), &_index_list, &ffi::DCRTPolyGenNullPublicKey());
 
     let mut _x_1 = CxxVector::<f64>::new();
     _x_1.pin_mut().push(0.25);
@@ -46,7 +46,7 @@ fn main()
     _x_2.pin_mut().push(0.5);
     _x_2.pin_mut().push(0.25);
 
-    let _dcrt_poly_params = ffi::GenNullDCRTPolyParams();
+    let _dcrt_poly_params = ffi::DCRTPolyGenNullParams();
     let _p_txt_1 = _cc.MakeCKKSPackedPlaintext(&_x_1, 1, 0, &_dcrt_poly_params, 0);
     let _p_txt_2 = _cc.MakeCKKSPackedPlaintext(&_x_2, 1, 0, &_dcrt_poly_params, 0);
 

src/Ciphertext.cc

@@ -22,7 +22,7 @@ const std::shared_ptr<CiphertextImpl>& CiphertextDCRTPoly::GetRef() const noexce
 }
 
 // Generator functions
-std::unique_ptr<CiphertextDCRTPoly> GenNullCiphertext()
+std::unique_ptr<CiphertextDCRTPoly> DCRTPolyGenNullCiphertext()
 {
     return std::make_unique<CiphertextDCRTPoly>();
 }

src/Ciphertext.h

@@ -25,6 +25,6 @@ public:
 };
 
 // Generator functions
-[[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> GenNullCiphertext();
+[[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> DCRTPolyGenNullCiphertext();
 
 } // openfhe

src/CryptoContext.cc

@@ -1081,102 +1081,104 @@ const std::shared_ptr<CryptoContextImpl>& CryptoContextDCRTPoly::GetRef() const
 }
 
 // cxx currently does not support static class methods
-void ClearEvalMultKeys()
+void DCRTPolyClearEvalMultKeys()
 {
     CryptoContextImpl::ClearEvalMultKeys();
 }
-void ClearEvalMultKeysById(const std::string& id)
+void DCRTPolyClearEvalMultKeysById(const std::string& id)
 {
     CryptoContextImpl::ClearEvalMultKeys(id);
 }
-void ClearEvalMultKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext)
+void DCRTPolyClearEvalMultKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext)
 {
     CryptoContextImpl::ClearEvalMultKeys(cryptoContext.GetInternal());
 }
-void ClearEvalSumKeys()
+void DCRTPolyClearEvalSumKeys()
 {
     CryptoContextImpl::ClearEvalSumKeys();
 }
-void ClearEvalSumKeysById(const std::string& id)
+void DCRTPolyClearEvalSumKeysById(const std::string& id)
 {
     CryptoContextImpl::ClearEvalSumKeys(id);
 }
-void ClearEvalSumKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext)
+void DCRTPolyClearEvalSumKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext)
 {
     CryptoContextImpl::ClearEvalSumKeys(cryptoContext.GetInternal());
 }
-void ClearEvalAutomorphismKeys()
+void DCRTPolyClearEvalAutomorphismKeys()
 {
     CryptoContextImpl::ClearEvalAutomorphismKeys();
 }
-void ClearEvalAutomorphismKeysById(const std::string& id)
+void DCRTPolyClearEvalAutomorphismKeysById(const std::string& id)
 {
     CryptoContextImpl::ClearEvalAutomorphismKeys(id);
 }
-void ClearEvalAutomorphismKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext)
+void DCRTPolyClearEvalAutomorphismKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext)
 {
     CryptoContextImpl::ClearEvalAutomorphismKeys(cryptoContext.GetInternal());
 }
-std::unique_ptr<std::vector<uint32_t>> GetExistingEvalAutomorphismKeyIndices(
+std::unique_ptr<std::vector<uint32_t>> DCRTPolyGetExistingEvalAutomorphismKeyIndices(
     const std::string& keyTag)
 {
     return std::make_unique<std::vector<uint32_t>>(
         CryptoContextImpl::GetExistingEvalAutomorphismKeyIndices(keyTag));
 }
-std::unique_ptr<std::vector<uint32_t>> GetUniqueValues(const std::vector<uint32_t>& oldValues,
-    const std::vector<uint32_t>& newValues)
+std::unique_ptr<std::vector<uint32_t>> DCRTPolyGetUniqueValues(
+    const std::vector<uint32_t>& oldValues, const std::vector<uint32_t>& newValues)
 {
     return std::make_unique<std::vector<uint32_t>>(CryptoContextImpl::GetUniqueValues(oldValues,
         newValues));
 }
-std::unique_ptr<MapFromIndexToEvalKey> GetEvalAutomorphismKeyMap(const std::string& keyID)
+std::unique_ptr<MapFromIndexToEvalKey> DCRTPolyGetEvalAutomorphismKeyMap(const std::string& keyID)
 {
-    return std::make_unique<MapFromIndexToEvalKey>(
-        CryptoContextImpl::GetEvalAutomorphismKeyMapPtr(keyID));
+    return std::make_unique<MapFromIndexToEvalKey>(CryptoContextImpl::GetEvalAutomorphismKeyMapPtr(
+        keyID));
 }
-std::unique_ptr<MapFromIndexToEvalKey> GetCopyOfEvalSumKeyMap(const std::string& id)
+std::unique_ptr<MapFromIndexToEvalKey> DCRTPolyGetCopyOfEvalSumKeyMap(const std::string& id)
 {
     return std::make_unique<MapFromIndexToEvalKey>(
         std::make_shared<std::map<uint32_t, std::shared_ptr<EvalKeyImpl>>>(
         CryptoContextImpl::GetEvalSumKeyMap(id)));
 }
-std::unique_ptr<MapFromIndexToEvalKey> GetEvalAutomorphismKeyMapPtr(const std::string& keyID)
+std::unique_ptr<MapFromIndexToEvalKey> DCRTPolyGetEvalAutomorphismKeyMapPtr(
+    const std::string& keyID)
 {
     return std::make_unique<MapFromIndexToEvalKey>(CryptoContextImpl::GetEvalAutomorphismKeyMapPtr(
         keyID));
 }
-void InsertEvalAutomorphismKey(const MapFromIndexToEvalKey& evalKeyMap, const std::string& keyTag)
+void DCRTPolyInsertEvalAutomorphismKey(const MapFromIndexToEvalKey& evalKeyMap,
+    const std::string& keyTag)
 {
     CryptoContextImpl::InsertEvalAutomorphismKey(evalKeyMap.GetInternal(), keyTag);
 }
-void InsertEvalSumKey(const MapFromIndexToEvalKey& mapToInsert, const std::string& keyTag)
+void DCRTPolyInsertEvalSumKey(const MapFromIndexToEvalKey& mapToInsert, const std::string& keyTag)
 {
     CryptoContextImpl::InsertEvalSumKey(mapToInsert.GetInternal(), keyTag);
 }
-std::unique_ptr<VectorOfEvalKeys> GetCopyOfEvalMultKeyVector(const std::string& keyID)
+std::unique_ptr<VectorOfEvalKeys> DCRTPolyGetCopyOfEvalMultKeyVector(const std::string& keyID)
 {
     return std::make_unique<VectorOfEvalKeys>(CryptoContextImpl::GetEvalMultKeyVector(keyID));
 }
-void InsertEvalMultKey(const VectorOfEvalKeys& evalKeyVec)
+void DCRTPolyInsertEvalMultKey(const VectorOfEvalKeys& evalKeyVec)
 {
     CryptoContextImpl::InsertEvalMultKey(evalKeyVec.GetInternal());
 }
-std::unique_ptr<MapFromStringToVectorOfEvalKeys> GetCopyOfAllEvalMultKeys()
+std::unique_ptr<MapFromStringToVectorOfEvalKeys> DCRTPolyGetCopyOfAllEvalMultKeys()
 {
     return std::make_unique<MapFromStringToVectorOfEvalKeys>(
         CryptoContextImpl::GetAllEvalMultKeys());
 }
-std::unique_ptr<MapFromStringToMapFromIndexToEvalKey> GetCopyOfAllEvalSumKeys()
+std::unique_ptr<MapFromStringToMapFromIndexToEvalKey> DCRTPolyGetCopyOfAllEvalSumKeys()
 {
     return std::make_unique<MapFromStringToMapFromIndexToEvalKey>(
         CryptoContextImpl::GetAllEvalSumKeys());
 }
-std::unique_ptr<MapFromStringToMapFromIndexToEvalKey> GetCopyOfAllEvalAutomorphismKeys()
+std::unique_ptr<MapFromStringToMapFromIndexToEvalKey> DCRTPolyGetCopyOfAllEvalAutomorphismKeys()
 {
     return std::make_unique<MapFromStringToMapFromIndexToEvalKey>(
         CryptoContextImpl::GetAllEvalAutomorphismKeys());
 }
-std::unique_ptr<Plaintext> GetPlaintextForDecrypt(const PlaintextEncodings pte,
+std::unique_ptr<Plaintext> DCRTPolyGetPlaintextForDecrypt(const PlaintextEncodings pte,
     const DCRTPolyParams& evp, const EncodingParams& ep)
 {
     return std::make_unique<Plaintext>(CryptoContextImpl::GetPlaintextForDecrypt(pte,
@@ -1184,19 +1186,22 @@ std::unique_ptr<Plaintext> GetPlaintextForDecrypt(const PlaintextEncodings pte,
 }
 
 // Generator functions
-std::unique_ptr<CryptoContextDCRTPoly> GenNullCryptoContext()
+std::unique_ptr<CryptoContextDCRTPoly> DCRTPolyGenNullCryptoContext()
 {
     return std::make_unique<CryptoContextDCRTPoly>();
 }
-std::unique_ptr<CryptoContextDCRTPoly> GenCryptoContextByParamsBFVRNS(const ParamsBFVRNS& params)
+std::unique_ptr<CryptoContextDCRTPoly> DCRTPolyGenCryptoContextByParamsBFVRNS(
+    const ParamsBFVRNS& params)
 {
     return std::make_unique<CryptoContextDCRTPoly>(params);
 }
-std::unique_ptr<CryptoContextDCRTPoly> GenCryptoContextByParamsBGVRNS(const ParamsBGVRNS& params)
+std::unique_ptr<CryptoContextDCRTPoly> DCRTPolyGenCryptoContextByParamsBGVRNS(
+    const ParamsBGVRNS& params)
 {
     return std::make_unique<CryptoContextDCRTPoly>(params);
 }
-std::unique_ptr<CryptoContextDCRTPoly> GenCryptoContextByParamsCKKSRNS(const ParamsCKKSRNS& params)
+std::unique_ptr<CryptoContextDCRTPoly> DCRTPolyGenCryptoContextByParamsCKKSRNS(
+    const ParamsCKKSRNS& params)
 {
     return std::make_unique<CryptoContextDCRTPoly>(params);
 }

src/CryptoContext.h

@@ -94,10 +94,10 @@ public:
     void EvalMultKeysGen(const PrivateKeyDCRTPoly& key) const;
     void EvalRotateKeyGen(const PrivateKeyDCRTPoly& privateKey,
         const std::vector<int32_t>& indexList,
-        const PublicKeyDCRTPoly& publicKey /* GenNullPublicKey() */) const;
+        const PublicKeyDCRTPoly& publicKey /* GenNullPublicKeyDCRTPoly() */) const;
     void EvalAtIndexKeyGen(const PrivateKeyDCRTPoly& privateKey,
         const std::vector<int32_t>& indexList,
-        const PublicKeyDCRTPoly& publicKey /* GenNullPublicKey() */) const;
+        const PublicKeyDCRTPoly& publicKey /* GenNullPublicKeyDCRTPoly() */) const;
     void EvalCKKStoFHEWPrecompute(const double scale /* 1.0 */) const;
     [[nodiscard]] uint32_t GetRingDimension() const;
     [[nodiscard]] uint32_t GetCyclotomicOrder() const;
@@ -301,7 +301,7 @@ public:
         const size_t levels /* 1 */) const;
     [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> ReEncrypt(
         const CiphertextDCRTPoly& ciphertext, const EvalKeyDCRTPoly& evalKey,
-        const PublicKeyDCRTPoly& publicKey /* GenNullPublicKey() */) const;
+        const PublicKeyDCRTPoly& publicKey /* GenNullPublicKeyDCRTPoly() */) const;
     [[nodiscard]] std::unique_ptr<EvalKeyDCRTPoly> KeySwitchGen(
         const PrivateKeyDCRTPoly& oldPrivateKey, const PrivateKeyDCRTPoly& newPrivateKey) const;
     [[nodiscard]] std::unique_ptr<EvalKeyDCRTPoly> ReKeyGen(
@@ -319,7 +319,7 @@ public:
         const EvalKeyDCRTPoly& evalKey1, const EvalKeyDCRTPoly& evalKey2,
         const std::string& keyId /* "" */) const;
     void EvalSumKeyGen(const PrivateKeyDCRTPoly& privateKey,
-        const PublicKeyDCRTPoly& publicKey /* GenNullPublicKey() */) const;
+        const PublicKeyDCRTPoly& publicKey /* GenNullPublicKeyDCRTPoly() */) const;
     void EvalCKKStoFHEWKeyGen(const KeyPairDCRTPoly& keyPair, const LWEPrivateKey& lwesk) const;
     void EvalFHEWtoCKKSKeyGen(const KeyPairDCRTPoly& keyPair, const LWEPrivateKey& lwesk,
         const uint32_t numSlots /* 0 */, const uint32_t numCtxts /* 0 */,
@@ -386,11 +386,11 @@ public:
         const PrivateKeyDCRTPoly& privateKey, const std::vector<uint32_t>& indexList) const;
     [[nodiscard]] std::unique_ptr<MapFromIndexToEvalKey> EvalSumRowsKeyGen(
         const PrivateKeyDCRTPoly& privateKey,
-        const PublicKeyDCRTPoly& publicKey /* GenNullPublicKey() */,
+        const PublicKeyDCRTPoly& publicKey /* GenNullPublicKeyDCRTPoly() */,
         const uint32_t rowSize /* 0 */, const uint32_t subringDim /* 0 */) const;
     [[nodiscard]] std::unique_ptr<MapFromIndexToEvalKey> EvalSumColsKeyGen(
         const PrivateKeyDCRTPoly& privateKey,
-        const PublicKeyDCRTPoly& publicKey /* GenNullPublicKey() */) const;
+        const PublicKeyDCRTPoly& publicKey /* GenNullPublicKeyDCRTPoly() */) const;
     [[nodiscard]] std::unique_ptr<MapFromIndexToEvalKey> MultiEvalAutomorphismKeyGen(
         const PrivateKeyDCRTPoly& privateKey, const MapFromIndexToEvalKey& evalKeyMap,
         const std::vector<uint32_t>& indexList, const std::string& keyId /* "" */) const;
@@ -434,45 +434,47 @@ public:
 };
 
 // cxx currently does not support static class methods
-void ClearEvalMultKeys();
-void ClearEvalMultKeysById(const std::string& id);
-void ClearEvalMultKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext);
-void ClearEvalSumKeys();
-void ClearEvalSumKeysById(const std::string& id);
-void ClearEvalSumKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext);
-void ClearEvalAutomorphismKeys();
-void ClearEvalAutomorphismKeysById(const std::string& id);
-void ClearEvalAutomorphismKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext);
-[[nodiscard]] std::unique_ptr<std::vector<uint32_t>> GetExistingEvalAutomorphismKeyIndices(
+void DCRTPolyClearEvalMultKeys();
+void DCRTPolyClearEvalMultKeysById(const std::string& id);
+void DCRTPolyClearEvalMultKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext);
+void DCRTPolyClearEvalSumKeys();
+void DCRTPolyClearEvalSumKeysById(const std::string& id);
+void DCRTPolyClearEvalSumKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext);
+void DCRTPolyClearEvalAutomorphismKeys();
+void DCRTPolyClearEvalAutomorphismKeysById(const std::string& id);
+void DCRTPolyClearEvalAutomorphismKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext);
+[[nodiscard]] std::unique_ptr<std::vector<uint32_t>> DCRTPolyGetExistingEvalAutomorphismKeyIndices(
     const std::string& keyTag);
-[[nodiscard]] std::unique_ptr<std::vector<uint32_t>> GetUniqueValues(
+[[nodiscard]] std::unique_ptr<std::vector<uint32_t>> DCRTPolyGetUniqueValues(
     const std::vector<uint32_t>& oldValues, const std::vector<uint32_t>& newValues);
-[[nodiscard]] std::unique_ptr<MapFromIndexToEvalKey> GetEvalAutomorphismKeyMap(
+[[nodiscard]] std::unique_ptr<MapFromIndexToEvalKey> DCRTPolyGetEvalAutomorphismKeyMap(
     const std::string& keyID);
-[[nodiscard]] std::unique_ptr<MapFromIndexToEvalKey> GetCopyOfEvalSumKeyMap(const std::string& id);
-[[nodiscard]] std::unique_ptr<MapFromIndexToEvalKey> GetEvalAutomorphismKeyMapPtr(
+[[nodiscard]] std::unique_ptr<MapFromIndexToEvalKey> DCRTPolyGetCopyOfEvalSumKeyMap(
+    const std::string& id);
+[[nodiscard]] std::unique_ptr<MapFromIndexToEvalKey> DCRTPolyGetEvalAutomorphismKeyMapPtr(
     const std::string& keyID);
-void InsertEvalAutomorphismKey(const MapFromIndexToEvalKey& evalKeyMap,
+void DCRTPolyInsertEvalAutomorphismKey(const MapFromIndexToEvalKey& evalKeyMap,
     const std::string& keyTag /* "" */);
-void InsertEvalSumKey(const MapFromIndexToEvalKey& mapToInsert,
+void DCRTPolyInsertEvalSumKey(const MapFromIndexToEvalKey& mapToInsert,
     const std::string& keyTag /* "" */);
-[[nodiscard]] std::unique_ptr<VectorOfEvalKeys> GetCopyOfEvalMultKeyVector(
+[[nodiscard]] std::unique_ptr<VectorOfEvalKeys> DCRTPolyGetCopyOfEvalMultKeyVector(
     const std::string& keyID);
-void InsertEvalMultKey(const VectorOfEvalKeys& evalKeyVec);
-[[nodiscard]] std::unique_ptr<MapFromStringToVectorOfEvalKeys> GetCopyOfAllEvalMultKeys();
-[[nodiscard]] std::unique_ptr<MapFromStringToMapFromIndexToEvalKey> GetCopyOfAllEvalSumKeys();
+void DCRTPolyInsertEvalMultKey(const VectorOfEvalKeys& evalKeyVec);
+[[nodiscard]] std::unique_ptr<MapFromStringToVectorOfEvalKeys> DCRTPolyGetCopyOfAllEvalMultKeys();
 [[nodiscard]] std::unique_ptr<MapFromStringToMapFromIndexToEvalKey>
-    GetCopyOfAllEvalAutomorphismKeys();
-[[nodiscard]] std::unique_ptr<Plaintext> GetPlaintextForDecrypt(const PlaintextEncodings pte,
-    const DCRTPolyParams& evp, const EncodingParams& ep);
+    DCRTPolyGetCopyOfAllEvalSumKeys();
+[[nodiscard]] std::unique_ptr<MapFromStringToMapFromIndexToEvalKey>
+    DCRTPolyGetCopyOfAllEvalAutomorphismKeys();
+[[nodiscard]] std::unique_ptr<Plaintext> DCRTPolyGetPlaintextForDecrypt(
+    const PlaintextEncodings pte, const DCRTPolyParams& evp, const EncodingParams& ep);
 
 // Generator functions
-[[nodiscard]] std::unique_ptr<CryptoContextDCRTPoly> GenNullCryptoContext();
-[[nodiscard]] std::unique_ptr<CryptoContextDCRTPoly> GenCryptoContextByParamsBFVRNS(
+[[nodiscard]] std::unique_ptr<CryptoContextDCRTPoly> DCRTPolyGenNullCryptoContext();
+[[nodiscard]] std::unique_ptr<CryptoContextDCRTPoly> DCRTPolyGenCryptoContextByParamsBFVRNS(
     const ParamsBFVRNS& params);
-[[nodiscard]] std::unique_ptr<CryptoContextDCRTPoly> GenCryptoContextByParamsBGVRNS(
+[[nodiscard]] std::unique_ptr<CryptoContextDCRTPoly> DCRTPolyGenCryptoContextByParamsBGVRNS(
     const ParamsBGVRNS& params);
-[[nodiscard]] std::unique_ptr<CryptoContextDCRTPoly> GenCryptoContextByParamsCKKSRNS(
+[[nodiscard]] std::unique_ptr<CryptoContextDCRTPoly> DCRTPolyGenCryptoContextByParamsCKKSRNS(
     const ParamsCKKSRNS& params);
 
 } // openfhe

src/DCRTPoly.cc

@@ -16,7 +16,7 @@ std::shared_ptr<lbcrypto::DCRTPoly::Params> DCRTPolyParams::GetInternal() const
 }
 
 // Generator functions
-std::unique_ptr<DCRTPolyParams> GenNullDCRTPolyParams()
+std::unique_ptr<DCRTPolyParams> DCRTPolyGenNullParams()
 {
     return std::make_unique<DCRTPolyParams>();
 }

src/DCRTPoly.h

@@ -31,6 +31,6 @@ public:
 };
 
 // Generator functions
-[[nodiscard]] std::unique_ptr<DCRTPolyParams> GenNullDCRTPolyParams();
+[[nodiscard]] std::unique_ptr<DCRTPolyParams> DCRTPolyGenNullParams();
 
 } // openfhe

src/PublicKey.cc

@@ -22,7 +22,7 @@ const std::shared_ptr<PublicKeyImpl>& PublicKeyDCRTPoly::GetRef() const noexcept
 }
 
 // Generator functions
-std::unique_ptr<PublicKeyDCRTPoly> GenNullPublicKey()
+std::unique_ptr<PublicKeyDCRTPoly> DCRTPolyGenNullPublicKey()
 {
     return std::make_unique<PublicKeyDCRTPoly>();
 }

src/PublicKey.h

@@ -25,6 +25,6 @@ public:
 };
 
 // Generator functions
-[[nodiscard]] std::unique_ptr<PublicKeyDCRTPoly> GenNullPublicKey();
+[[nodiscard]] std::unique_ptr<PublicKeyDCRTPoly> DCRTPolyGenNullPublicKey();
 
 } // openfhe

src/SerialDeserial.cc

@@ -16,33 +16,33 @@ template <typename ST, typename Object>
     return funcPtr(location, object, ST{});
 }
 template <typename Object>
-[[nodiscard]] bool Serial(const std::string& location, Object& object, const SerialMode serialMode)
+[[nodiscard]] bool Deserial(const std::string& location, Object& object,
+    const SerialMode serialMode)
 {
     if (serialMode == SerialMode::BINARY)
     {
         return SerialDeserial<lbcrypto::SerType::SERBINARY, decltype(object.GetRef())>(location,
-            lbcrypto::Serial::SerializeToFile, object.GetRef());
+            lbcrypto::Serial::DeserializeFromFile, object.GetRef());
     }
     if (serialMode == SerialMode::JSON)
     {
         return SerialDeserial<lbcrypto::SerType::SERJSON, decltype(object.GetRef())>(location,
-            lbcrypto::Serial::SerializeToFile, object.GetRef());
+            lbcrypto::Serial::DeserializeFromFile, object.GetRef());
     }
     return false;
 }
 template <typename Object>
-[[nodiscard]] bool Deserial(const std::string& location, Object& object,
-    const SerialMode serialMode)
+[[nodiscard]] bool Serial(const std::string& location, Object& object, const SerialMode serialMode)
 {
     if (serialMode == SerialMode::BINARY)
     {
         return SerialDeserial<lbcrypto::SerType::SERBINARY, decltype(object.GetRef())>(location,
-            lbcrypto::Serial::DeserializeFromFile, object.GetRef());
+            lbcrypto::Serial::SerializeToFile, object.GetRef());
     }
     if (serialMode == SerialMode::JSON)
     {
         return SerialDeserial<lbcrypto::SerType::SERJSON, decltype(object.GetRef())>(location,
-            lbcrypto::Serial::DeserializeFromFile, object.GetRef());
+            lbcrypto::Serial::SerializeToFile, object.GetRef());
     }
     return false;
 }
@@ -58,31 +58,31 @@ template <typename ST, typename Stream, typename FStream, typename... Types>
 }
 
 // Ciphertext
-bool DeserializeCiphertextFromFile(const std::string& ciphertextLocation,
+bool DCRTPolyDeserializeCiphertextFromFile(const std::string& ciphertextLocation,
     CiphertextDCRTPoly& ciphertext, const SerialMode serialMode)
 {
     return Deserial(ciphertextLocation, ciphertext, serialMode);
 }
-bool SerializeCiphertextToFile(const std::string& ciphertextLocation,
+bool DCRTPolySerializeCiphertextToFile(const std::string& ciphertextLocation,
     const CiphertextDCRTPoly& ciphertext, const SerialMode serialMode)
 {
     return Serial(ciphertextLocation, ciphertext, serialMode);
 }
 
-// CryptoContextDCRTPoly
-bool DeserializeCryptoContextFromFile(const std::string& ccLocation,
+// CryptoContext
+bool DCRTPolyDeserializeCryptoContextFromFile(const std::string& ccLocation,
     CryptoContextDCRTPoly& cryptoContext, const SerialMode serialMode)
 {
     return Deserial(ccLocation, cryptoContext, serialMode);
 }
-bool SerializeCryptoContextToFile(const std::string& ccLocation,
+bool DCRTPolySerializeCryptoContextToFile(const std::string& ccLocation,
     const CryptoContextDCRTPoly& cryptoContext, const SerialMode serialMode)
 {
     return Serial(ccLocation, cryptoContext, serialMode);
 }
 
 // EvalAutomorphismKey
-bool DeserializeEvalAutomorphismKeyFromFile(const std::string& automorphismKeyLocation,
+bool DCRTPolyDeserializeEvalAutomorphismKeyFromFile(const std::string& automorphismKeyLocation,
     const SerialMode serialMode)
 {
     if (serialMode == SerialMode::BINARY)
@@ -97,7 +97,7 @@ bool DeserializeEvalAutomorphismKeyFromFile(const std::string& automorphismKeyLo
     }
     return false;
 }
-bool SerializeEvalAutomorphismKeyByIdToFile(const std::string& automorphismKeyLocation,
+bool DCRTPolySerializeEvalAutomorphismKeyByIdToFile(const std::string& automorphismKeyLocation,
     const SerialMode serialMode, const std::string& id)
 {
     if (serialMode == SerialMode::BINARY)
@@ -112,7 +112,7 @@ bool SerializeEvalAutomorphismKeyByIdToFile(const std::string& automorphismKeyLo
     }
     return false;
 }
-bool SerializeEvalAutomorphismKeyToFile(const std::string& automorphismKeyLocation,
+bool DCRTPolySerializeEvalAutomorphismKeyToFile(const std::string& automorphismKeyLocation,
     const CryptoContextDCRTPoly& cryptoContext, const SerialMode serialMode)
 {
     if (serialMode == SerialMode::BINARY)
@@ -131,7 +131,7 @@ bool SerializeEvalAutomorphismKeyToFile(const std::string& automorphismKeyLocati
 }
 
 // EvalMultKey
-bool DeserializeEvalMultKeyFromFile(const std::string& multKeyLocation,
+bool DCRTPolyDeserializeEvalMultKeyFromFile(const std::string& multKeyLocation,
     const SerialMode serialMode)
 {
     if (serialMode == SerialMode::BINARY)
@@ -146,7 +146,7 @@ bool DeserializeEvalMultKeyFromFile(const std::string& multKeyLocation,
     }
     return false;
 }
-bool SerializeEvalMultKeyByIdToFile(const std::string& multKeyLocation,
+bool SerializeEvalMultKeyDCRTPolyByIdToFile(const std::string& multKeyLocation,
     const SerialMode serialMode, const std::string& id)
 {
     if (serialMode == SerialMode::BINARY)
@@ -161,7 +161,7 @@ bool SerializeEvalMultKeyByIdToFile(const std::string& multKeyLocation,
     }
     return false;
 }
-bool SerializeEvalMultKeyToFile(const std::string& multKeyLocation,
+bool DCRTPolySerializeEvalMultKeyToFile(const std::string& multKeyLocation,
     const CryptoContextDCRTPoly& cryptoContext, const SerialMode serialMode)
 {
     if (serialMode == SerialMode::BINARY)
@@ -178,7 +178,7 @@ bool SerializeEvalMultKeyToFile(const std::string& multKeyLocation,
 }
 
 // EvalSumKey
-bool DeserializeEvalSumKeyFromFile(const std::string& sumKeyLocation, const SerialMode serialMode)
+bool DCRTPolyDeserializeEvalSumKeyFromFile(const std::string& sumKeyLocation, const SerialMode serialMode)
 {
     if (serialMode == SerialMode::BINARY)
     {
@@ -192,7 +192,7 @@ bool DeserializeEvalSumKeyFromFile(const std::string& sumKeyLocation, const Seri
     }
     return false;
 }
-bool SerializeEvalSumKeyByIdToFile(const std::string& sumKeyLocation,
+bool DCRTPolySerializeEvalSumKeyByIdToFile(const std::string& sumKeyLocation,
     const SerialMode serialMode, const std::string& id)
 {
     if (serialMode == SerialMode::BINARY)
@@ -207,7 +207,7 @@ bool SerializeEvalSumKeyByIdToFile(const std::string& sumKeyLocation,
     }
     return false;
 }
-bool SerializeEvalSumKeyToFile(const std::string& sumKeyLocation,
+bool DCRTPolySerializeEvalSumKeyToFile(const std::string& sumKeyLocation,
     const CryptoContextDCRTPoly& cryptoContext, const SerialMode serialMode)
 {
     if (serialMode == SerialMode::BINARY)
@@ -226,12 +226,12 @@ bool SerializeEvalSumKeyToFile(const std::string& sumKeyLocation,
 }
 
 // PublicKey
-bool DeserializePublicKeyFromFile(const std::string& publicKeyLocation,
+bool DCRTPolyDeserializePublicKeyFromFile(const std::string& publicKeyLocation,
     PublicKeyDCRTPoly& publicKey, const SerialMode serialMode)
 {
     return Deserial(publicKeyLocation, publicKey, serialMode);
 }
-bool SerializePublicKeyToFile(const std::string& publicKeyLocation,
+bool DCRTPolySerializePublicKeyToFile(const std::string& publicKeyLocation,
     const PublicKeyDCRTPoly& publicKey, const SerialMode serialMode)
 {
     return Serial(publicKeyLocation, publicKey, serialMode);

src/SerialDeserial.h

@@ -12,46 +12,47 @@ class CryptoContextDCRTPoly;
 class PublicKeyDCRTPoly;
 
 // Ciphertext
-[[nodiscard]] bool DeserializeCiphertextFromFile(const std::string& ciphertextLocation,
+[[nodiscard]] bool DCRTPolyDeserializeCiphertextFromFile(const std::string& ciphertextLocation,
     CiphertextDCRTPoly& ciphertext, const SerialMode serialMode);
-[[nodiscard]] bool SerializeCiphertextToFile(const std::string& ciphertextLocation,
+[[nodiscard]] bool DCRTPolySerializeCiphertextToFile(const std::string& ciphertextLocation,
     const CiphertextDCRTPoly& ciphertext, const SerialMode serialMode);
 
-// CryptoContextDCRTPoly
-[[nodiscard]] bool DeserializeCryptoContextFromFile(const std::string& ccLocation,
+// CryptoContext
+[[nodiscard]] bool DCRTPolyDeserializeCryptoContextFromFile(const std::string& ccLocation,
     CryptoContextDCRTPoly& cryptoContext, const SerialMode serialMode);
-[[nodiscard]] bool SerializeCryptoContextToFile(const std::string& ccLocation,
+[[nodiscard]] bool DCRTPolySerializeCryptoContextToFile(const std::string& ccLocation,
     const CryptoContextDCRTPoly& cryptoContext, const SerialMode serialMode);
 
 // EvalAutomorphismKey
-[[nodiscard]] bool DeserializeEvalMultKeyFromFile(const std::string& multKeyLocation,
+[[nodiscard]] bool DCRTPolyDeserializeEvalMultKeyFromFile(const std::string& multKeyLocation,
     const SerialMode serialMode);
-[[nodiscard]] bool SerializeEvalMultKeyByIdToFile(const std::string& multKeyLocation,
+[[nodiscard]] bool DCRTPolySerializeEvalMultKeyByIdToFile(const std::string& multKeyLocation,
     const SerialMode serialMode, const std::string& id);
-[[nodiscard]] bool SerializeEvalMultKeyToFile(const std::string& multKeyLocation,
+[[nodiscard]] bool DCRTPolySerializeEvalMultKeyToFile(const std::string& multKeyLocation,
     const CryptoContextDCRTPoly& cryptoContext, const SerialMode serialMode);
 
 // EvalMultKey
-[[nodiscard]] bool DeserializeEvalAutomorphismKeyFromFile(
+[[nodiscard]] bool DCRTPolyDeserializeEvalAutomorphismKeyFromFile(
     const std::string& automorphismKeyLocation, const SerialMode serialMode);
-[[nodiscard]] bool SerializeEvalAutomorphismKeyByIdToFile(
+[[nodiscard]] bool DCRTPolySerializeEvalAutomorphismKeyByIdToFile(
     const std::string& automorphismKeyLocation, const SerialMode serialMode,
     const std::string& id);
-[[nodiscard]] bool SerializeEvalAutomorphismKeyToFile(const std::string& automorphismKeyLocation,
-    const CryptoContextDCRTPoly& cryptoContext, const SerialMode serialMode);
+[[nodiscard]] bool DCRTPolySerializeEvalAutomorphismKeyToFile(
+    const std::string& automorphismKeyLocation, const CryptoContextDCRTPoly& cryptoContext,
+    const SerialMode serialMode);
 
 // EvalSumKey
-[[nodiscard]] bool DeserializeEvalSumKeyFromFile(const std::string& sumKeyLocation,
+[[nodiscard]] bool DCRTPolyDeserializeEvalSumKeyFromFile(const std::string& sumKeyLocation,
     const SerialMode serialMode);
-[[nodiscard]] bool SerializeEvalSumKeyByIdToFile(const std::string& sumKeyLocation,
+[[nodiscard]] bool DCRTPolySerializeEvalSumKeyByIdToFile(const std::string& sumKeyLocation,
     const SerialMode serialMode, const std::string& id);
-[[nodiscard]] bool SerializeEvalSumKeyToFile(const std::string& sumKeyLocation,
+[[nodiscard]] bool DCRTPolySerializeEvalSumKeyToFile(const std::string& sumKeyLocation,
     const CryptoContextDCRTPoly& cryptoContext, const SerialMode serialMode);
 
 // PublicKey
-[[nodiscard]] bool DeserializePublicKeyFromFile(const std::string& publicKeyLocation,
+[[nodiscard]] bool DCRTPolyDeserializePublicKeyFromFile(const std::string& publicKeyLocation,
     PublicKeyDCRTPoly& publicKey, const SerialMode serialMode);
-[[nodiscard]] bool SerializePublicKeyToFile(const std::string& publicKeyLocation,
+[[nodiscard]] bool DCRTPolySerializePublicKeyToFile(const std::string& publicKeyLocation,
     const PublicKeyDCRTPoly& publicKey, const SerialMode serialMode);
 
 } // openfhe

src/lib.rs

@@ -228,7 +228,7 @@ pub mod ffi
     unsafe extern "C++"
     {
         // Generator functions
-        fn GenNullCiphertext() -> UniquePtr<CiphertextDCRTPoly>;
+        fn DCRTPolyGenNullCiphertext() -> UniquePtr<CiphertextDCRTPoly>;
     }
 
     // CryptoContextDCRTPoly
@@ -302,7 +302,7 @@ pub mod ffi
                        -> UniquePtr<CiphertextDCRTPoly>;
         fn EvalAtIndexKeyGen(self: &CryptoContextDCRTPoly, privateKey: &PrivateKeyDCRTPoly,
                              indexList: &CxxVector<i32>,
-                             publicKey: /* GenNullPublicKey() */ &PublicKeyDCRTPoly);
+                             publicKey: /* DCRTPolyGenNullPublicKey() */ &PublicKeyDCRTPoly);
         fn EvalAutomorphism(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly, i: u32,
                             evalKeyMap: &MapFromIndexToEvalKey) -> UniquePtr<CiphertextDCRTPoly>;
         fn EvalAutomorphismKeyGen(self: &CryptoContextDCRTPoly, privateKey: &PrivateKeyDCRTPoly,
@@ -445,7 +445,7 @@ pub mod ffi
                       -> UniquePtr<CiphertextDCRTPoly>;
         fn EvalRotateKeyGen(self: &CryptoContextDCRTPoly, privateKey: &PrivateKeyDCRTPoly,
                             indexList: &CxxVector<i32>,
-                            publicKey: /* GenNullPublicKey() */ &PublicKeyDCRTPoly);
+                            publicKey: /* DCRTPolyGenNullPublicKey() */ &PublicKeyDCRTPoly);
         fn EvalSchemeSwitchingKeyGen(self: &CryptoContextDCRTPoly, keyPair: &KeyPairDCRTPoly,
                                      lwesk: &LWEPrivateKey);
         fn EvalSin(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly, a: f64, b: f64,
@@ -495,15 +495,15 @@ pub mod ffi
         fn EvalSumCols(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly, rowSize: u32,
                        evalSumKeyMap: &MapFromIndexToEvalKey) -> UniquePtr<CiphertextDCRTPoly>;
         fn EvalSumColsKeyGen(self: &CryptoContextDCRTPoly, privateKey: &PrivateKeyDCRTPoly,
-                             publicKey: /* GenNullPublicKey() */ &PublicKeyDCRTPoly)
+                             publicKey: /* DCRTPolyGenNullPublicKey() */ &PublicKeyDCRTPoly)
                              -> UniquePtr<MapFromIndexToEvalKey>;
         fn EvalSumKeyGen(self: &CryptoContextDCRTPoly, privateKey: &PrivateKeyDCRTPoly,
-                         publicKey: /* GenNullPublicKey() */ &PublicKeyDCRTPoly);
+                         publicKey: /* DCRTPolyGenNullPublicKey() */ &PublicKeyDCRTPoly);
         fn EvalSumRows(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly, rowSize: u32,
                        evalSumKeyMap: &MapFromIndexToEvalKey, subringDim: /* 0 */ u32)
                        -> UniquePtr<CiphertextDCRTPoly>;
         fn EvalSumRowsKeyGen(self: &CryptoContextDCRTPoly, privateKey: &PrivateKeyDCRTPoly,
-                             publicKey: /* GenNullPublicKey() */ &PublicKeyDCRTPoly,
+                             publicKey: /* DCRTPolyGenNullPublicKey() */ &PublicKeyDCRTPoly,
                              rowSize: /* 0 */ u32, subringDim: /* 0 */ u32)
                              -> UniquePtr<MapFromIndexToEvalKey>;
         fn FindAutomorphismIndex(self: &CryptoContextDCRTPoly, idx: u32) -> u32;
@@ -554,13 +554,13 @@ pub mod ffi
                               evalKey: &EvalKeyDCRTPoly, levels: /* 1 */ usize);
         fn MakeCKKSPackedPlaintext(self: &CryptoContextDCRTPoly, value: &CxxVector<f64>,
                                    scaleDeg: /* 1 */ usize, level: /* 0 */ u32,
-                                   params: /* GenNullDCRTPolyParams() */ &DCRTPolyParams,
+                                   params: /* DCRTPolyGenNullParams() */ &DCRTPolyParams,
                                    slots: /* 0 */ u32) -> UniquePtr<Plaintext>;
         fn MakeCKKSPackedPlaintextByVectorOfComplex(self: &CryptoContextDCRTPoly,
                                                     value: &CxxVector<ComplexPair>,
                                                     scaleDeg: /* 1 */ usize, level: /* 0 */ u32,
                                                     params:
-                                                    /* GenNullDCRTPolyParams() */ &DCRTPolyParams,
+                                                    /* DCRTPolyGenNullParams() */ &DCRTPolyParams,
                                                     slots: /* 0 */ u32) -> UniquePtr<Plaintext>;
         fn MakeCoefPackedPlaintext(self: &CryptoContextDCRTPoly, value: &CxxVector<i64>,
                                    noiseScaleDeg: /* 1 */ usize, level: /* 0 */ u32)
@@ -625,7 +625,7 @@ pub mod ffi
                                                  -> UniquePtr<KeyPairDCRTPoly>;
         fn ReEncrypt(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly,
                      evalKey: &EvalKeyDCRTPoly,
-                     publicKey: /* GenNullPublicKey() */ &PublicKeyDCRTPoly)
+                     publicKey: /* DCRTPolyGenNullPublicKey() */ &PublicKeyDCRTPoly)
                      -> UniquePtr<CiphertextDCRTPoly>;
         fn ReKeyGen(self: &CryptoContextDCRTPoly, oldPrivateKey: &PrivateKeyDCRTPoly,
                     newPublicKey: &PublicKeyDCRTPoly) -> UniquePtr<EvalKeyDCRTPoly>;
@@ -647,47 +647,52 @@ pub mod ffi
         fn SparseKeyGen(self: &CryptoContextDCRTPoly) -> UniquePtr<KeyPairDCRTPoly>;
 
         // cxx currently does not support static class methods
-        fn ClearEvalAutomorphismKeys();
-        fn ClearEvalAutomorphismKeysByCryptoContext(cryptoContext: &CryptoContextDCRTPoly);
-        fn ClearEvalAutomorphismKeysById(id: &CxxString);
-        fn ClearEvalMultKeys();
-        fn ClearEvalMultKeysByCryptoContext(cryptoContext: &CryptoContextDCRTPoly);
-        fn ClearEvalMultKeysById(id: &CxxString);
-        fn ClearEvalSumKeys();
-        fn ClearEvalSumKeysByCryptoContext(cryptoContext: &CryptoContextDCRTPoly);
-        fn ClearEvalSumKeysById(id: &CxxString);
-        fn GetCopyOfAllEvalAutomorphismKeys() -> UniquePtr<MapFromStringToMapFromIndexToEvalKey>;
-        fn GetCopyOfAllEvalMultKeys() -> UniquePtr<MapFromStringToVectorOfEvalKeys>;
-        fn GetCopyOfAllEvalSumKeys() -> UniquePtr<MapFromStringToMapFromIndexToEvalKey>;
-        fn GetCopyOfEvalMultKeyVector(keyID: &CxxString) -> UniquePtr<VectorOfEvalKeys>;
-        fn GetCopyOfEvalSumKeyMap(id: &CxxString) -> UniquePtr<MapFromIndexToEvalKey>;
-        fn GetEvalAutomorphismKeyMap(keyID: &CxxString) -> UniquePtr<MapFromIndexToEvalKey>;
-        fn GetEvalAutomorphismKeyMapPtr(keyID: &CxxString) -> UniquePtr<MapFromIndexToEvalKey>;
-        fn GetExistingEvalAutomorphismKeyIndices(keyTag: &CxxString) -> UniquePtr<CxxVector<u32>>;
-        fn GetPlaintextForDecrypt(pte: PlaintextEncodings, evp: &DCRTPolyParams,
-                                  ep: &EncodingParams) -> UniquePtr<Plaintext>;
-        fn GetUniqueValues(oldValues: &CxxVector<u32>, newValues: &CxxVector<u32>)
-                           -> UniquePtr<CxxVector<u32>>;
-        fn InsertEvalAutomorphismKey(evalKeyMap: &MapFromIndexToEvalKey,
-                                     keyTag: /* "" */ &CxxString);
-        fn InsertEvalMultKey(evalKeyVec: &VectorOfEvalKeys);
-        fn InsertEvalSumKey(mapToInsert: &MapFromIndexToEvalKey, keyTag: /* "" */ &CxxString);
+        fn DCRTPolyClearEvalAutomorphismKeys();
+        fn DCRTPolyClearEvalAutomorphismKeysByCryptoContext(cryptoContext: &CryptoContextDCRTPoly);
+        fn DCRTPolyClearEvalAutomorphismKeysById(id: &CxxString);
+        fn DCRTPolyClearEvalMultKeys();
+        fn DCRTPolyClearEvalMultKeysByCryptoContext(cryptoContext: &CryptoContextDCRTPoly);
+        fn DCRTPolyClearEvalMultKeysById(id: &CxxString);
+        fn DCRTPolyClearEvalSumKeys();
+        fn DCRTPolyClearEvalSumKeysByCryptoContext(cryptoContext: &CryptoContextDCRTPoly);
+        fn DCRTPolyClearEvalSumKeysById(id: &CxxString);
+        fn DCRTPolyGetCopyOfAllEvalAutomorphismKeys()
+            -> UniquePtr<MapFromStringToMapFromIndexToEvalKey>;
+        fn DCRTPolyGetCopyOfAllEvalMultKeys() -> UniquePtr<MapFromStringToVectorOfEvalKeys>;
+        fn DCRTPolyGetCopyOfAllEvalSumKeys() -> UniquePtr<MapFromStringToMapFromIndexToEvalKey>;
+        fn DCRTPolyGetCopyOfEvalMultKeyVector(keyID: &CxxString) -> UniquePtr<VectorOfEvalKeys>;
+        fn DCRTPolyGetCopyOfEvalSumKeyMap(id: &CxxString) -> UniquePtr<MapFromIndexToEvalKey>;
+        fn DCRTPolyGetEvalAutomorphismKeyMap(keyID: &CxxString)
+                                             -> UniquePtr<MapFromIndexToEvalKey>;
+        fn DCRTPolyGetEvalAutomorphismKeyMapPtr(keyID: &CxxString)
+                                                -> UniquePtr<MapFromIndexToEvalKey>;
+        fn DCRTPolyGetExistingEvalAutomorphismKeyIndices(keyTag: &CxxString)
+                                                         -> UniquePtr<CxxVector<u32>>;
+        fn DCRTPolyGetPlaintextForDecrypt(pte: PlaintextEncodings, evp: &DCRTPolyParams,
+                                          ep: &EncodingParams) -> UniquePtr<Plaintext>;
+        fn DCRTPolyGetUniqueValues(oldValues: &CxxVector<u32>, newValues: &CxxVector<u32>)
+                                   -> UniquePtr<CxxVector<u32>>;
+        fn DCRTPolyInsertEvalAutomorphismKey(evalKeyMap: &MapFromIndexToEvalKey,
+                                             keyTag: /* "" */ &CxxString);
+        fn DCRTPolyInsertEvalMultKey(evalKeyVec: &VectorOfEvalKeys);
+        fn DCRTPolyInsertEvalSumKey(mapToInsert: &MapFromIndexToEvalKey,
+                                    keyTag: /* "" */ &CxxString);
 
         // Generator functions
-        fn GenCryptoContextByParamsCKKSRNS(params: &ParamsCKKSRNS)
-                                           -> UniquePtr<CryptoContextDCRTPoly>;
-        fn GenCryptoContextByParamsBFVRNS(params: &ParamsBFVRNS)
-                                          -> UniquePtr<CryptoContextDCRTPoly>;
-        fn GenCryptoContextByParamsBGVRNS(params: &ParamsBGVRNS)
-                                          -> UniquePtr<CryptoContextDCRTPoly>;
-        fn GenNullCryptoContext() -> UniquePtr<CryptoContextDCRTPoly>;
+        fn DCRTPolyGenCryptoContextByParamsCKKSRNS(params: &ParamsCKKSRNS)
+                                                   -> UniquePtr<CryptoContextDCRTPoly>;
+        fn DCRTPolyGenCryptoContextByParamsBFVRNS(params: &ParamsBFVRNS)
+                                                  -> UniquePtr<CryptoContextDCRTPoly>;
+        fn DCRTPolyGenCryptoContextByParamsBGVRNS(params: &ParamsBGVRNS)
+                                                  -> UniquePtr<CryptoContextDCRTPoly>;
+        fn DCRTPolyGenNullCryptoContext() -> UniquePtr<CryptoContextDCRTPoly>;
     }
 
     // DCRTPolyParams
     unsafe extern "C++"
     {
         // Generator functions
-        fn GenNullDCRTPolyParams() -> UniquePtr<DCRTPolyParams>;
+        fn DCRTPolyGenNullParams() -> UniquePtr<DCRTPolyParams>;
     }
 
     // KeyPairDCRTPoly
@@ -1025,61 +1030,63 @@ pub mod ffi
     unsafe extern "C++"
     {
         // Generator functions
-        fn GenNullPublicKey() -> UniquePtr<PublicKeyDCRTPoly>;
+        fn DCRTPolyGenNullPublicKey() -> UniquePtr<PublicKeyDCRTPoly>;
     }
 
     // Serialize / Deserialize
     unsafe extern "C++"
     {
         // Ciphertext
-        fn DeserializeCiphertextFromFile(ciphertextLocation: &CxxString,
-                                         ciphertext: Pin<&mut CiphertextDCRTPoly>,
-                                         serialMode: SerialMode) -> bool;
-        fn SerializeCiphertextToFile(ciphertextLocation: &CxxString,
-                                     ciphertext: &CiphertextDCRTPoly, serialMode: SerialMode)
-                                     -> bool;
+        fn DCRTPolyDeserializeCiphertextFromFile(ciphertextLocation: &CxxString,
+                                                 ciphertext: Pin<&mut CiphertextDCRTPoly>,
+                                                 serialMode: SerialMode) -> bool;
+        fn DCRTPolySerializeCiphertextToFile(ciphertextLocation: &CxxString,
+                                             ciphertext: &CiphertextDCRTPoly,
+                                             serialMode: SerialMode) -> bool;
 
         // CryptoContextDCRTPoly
-        fn DeserializeCryptoContextFromFile(ccLocation: &CxxString,
-                                            cryptoContext: Pin<&mut CryptoContextDCRTPoly>,
-                                            serialMode: SerialMode) -> bool;
-        fn SerializeCryptoContextToFile(ccLocation: &CxxString,
-                                        cryptoContext: &CryptoContextDCRTPoly,
-                                        serialMode: SerialMode) -> bool;
+        fn DCRTPolyDeserializeCryptoContextFromFile(ccLocation: &CxxString,
+                                                    cryptoContext: Pin<&mut CryptoContextDCRTPoly>,
+                                                    serialMode: SerialMode) -> bool;
+        fn DCRTPolySerializeCryptoContextToFile(ccLocation: &CxxString,
+                                                cryptoContext: &CryptoContextDCRTPoly,
+                                                serialMode: SerialMode) -> bool;
 
         // EvalAutomorphismKey
-        fn DeserializeEvalAutomorphismKeyFromFile(automorphismKeyLocation: &CxxString,
+        fn DCRTPolyDeserializeEvalAutomorphismKeyFromFile(automorphismKeyLocation: &CxxString,
+                                                          serialMode: SerialMode) -> bool;
+        fn DCRTPolySerializeEvalAutomorphismKeyByIdToFile(automorphismKeyLocation: &CxxString,
+                                                          serialMode: SerialMode, id: &CxxString)
+                                                          -> bool;
+        fn DCRTPolySerializeEvalAutomorphismKeyToFile(automorphismKeyLocation: &CxxString,
+                                                      cryptoContext: &CryptoContextDCRTPoly,
+                                                      serialMode: SerialMode) -> bool;
+
+        // EvalMultKey
+        fn DCRTPolyDeserializeEvalMultKeyFromFile(multKeyLocation: &CxxString,
                                                   serialMode: SerialMode) -> bool;
-        fn SerializeEvalAutomorphismKeyByIdToFile(automorphismKeyLocation: &CxxString,
+        fn DCRTPolySerializeEvalMultKeyByIdToFile(multKeyLocation: &CxxString,
                                                   serialMode: SerialMode, id: &CxxString) -> bool;
-        fn SerializeEvalAutomorphismKeyToFile(automorphismKeyLocation: &CxxString,
+        fn DCRTPolySerializeEvalMultKeyToFile(multKeyLocation: &CxxString,
                                               cryptoContext: &CryptoContextDCRTPoly,
                                               serialMode: SerialMode) -> bool;
 
-        // EvalMultKey
-        fn DeserializeEvalMultKeyFromFile(multKeyLocation: &CxxString, serialMode: SerialMode)
-                                          -> bool;
-        fn SerializeEvalMultKeyByIdToFile(multKeyLocation: &CxxString, serialMode: SerialMode,
-                                          id: &CxxString) -> bool;
-        fn SerializeEvalMultKeyToFile(multKeyLocation: &CxxString,
-                                      cryptoContext: &CryptoContextDCRTPoly,
-                                      serialMode: SerialMode) -> bool;
-
         // EvalSumKey
-        fn DeserializeEvalSumKeyFromFile(sumKeyLocation: &CxxString, serialMode: SerialMode)
-                                         -> bool;
-        fn SerializeEvalSumKeyByIdToFile(sumKeyLocation: &CxxString, serialMode: SerialMode,
-                                         id: &CxxString) -> bool;
-        fn SerializeEvalSumKeyToFile(sumKeyLocation: &CxxString,
-                                     cryptoContext: &CryptoContextDCRTPoly, serialMode: SerialMode)
-                                     -> bool;
+        fn DCRTPolyDeserializeEvalSumKeyFromFile(sumKeyLocation: &CxxString,
+                                                 serialMode: SerialMode) -> bool;
+        fn DCRTPolySerializeEvalSumKeyByIdToFile(sumKeyLocation: &CxxString,
+                                                 serialMode: SerialMode, id: &CxxString) -> bool;
+        fn DCRTPolySerializeEvalSumKeyToFile(sumKeyLocation: &CxxString,
+                                             cryptoContext: &CryptoContextDCRTPoly,
+                                             serialMode: SerialMode) -> bool;
 
         // PublicKey
-        fn DeserializePublicKeyFromFile(publicKeyLocation: &CxxString,
-                                        publicKey: Pin<&mut PublicKeyDCRTPoly>,
-                                        serialMode: SerialMode) -> bool;
-        fn SerializePublicKeyToFile(publicKeyLocation: &CxxString, publicKey: &PublicKeyDCRTPoly,
-                                    serialMode: SerialMode) -> bool;
+        fn DCRTPolyDeserializePublicKeyFromFile(publicKeyLocation: &CxxString,
+                                                publicKey: Pin<&mut PublicKeyDCRTPoly>,
+                                                serialMode: SerialMode) -> bool;
+        fn DCRTPolySerializePublicKeyToFile(publicKeyLocation: &CxxString,
+                                            publicKey: &PublicKeyDCRTPoly,
+                                            serialMode: SerialMode) -> bool;
     }
 }
 
@@ -1096,7 +1103,7 @@ mod tests
         _cc_params_bfvrns.pin_mut().SetPlaintextModulus(65537);
         _cc_params_bfvrns.pin_mut().SetMultiplicativeDepth(2);
 
-        let _cc = ffi::GenCryptoContextByParamsBFVRNS(&_cc_params_bfvrns);
+        let _cc = ffi::DCRTPolyGenCryptoContextByParamsBFVRNS(&_cc_params_bfvrns);
         _cc.Enable(ffi::PKESchemeFeature::PKE);
         _cc.Enable(ffi::PKESchemeFeature::KEYSWITCH);
         _cc.Enable(ffi::PKESchemeFeature::LEVELEDSHE);
@@ -1109,7 +1116,7 @@ mod tests
         _index_list.pin_mut().push(2);
         _index_list.pin_mut().push(-1);
         _index_list.pin_mut().push(-2);
-        _cc.EvalRotateKeyGen(&_key_pair.GetPrivateKey(), &_index_list, &ffi::GenNullPublicKey());
+        _cc.EvalRotateKeyGen(&_key_pair.GetPrivateKey(), &_index_list, &ffi::DCRTPolyGenNullPublicKey());
 
         let mut _vector_of_ints_1 = CxxVector::<i64>::new();
         _vector_of_ints_1.pin_mut().push(1);
@@ -1214,7 +1221,7 @@ mod tests
         _cc_params_ckksrns.pin_mut().SetScalingModSize(_scale_mod_size);
         _cc_params_ckksrns.pin_mut().SetBatchSize(_batch_size);
 
-        let _cc = ffi::GenCryptoContextByParamsCKKSRNS(&_cc_params_ckksrns);
+        let _cc = ffi::DCRTPolyGenCryptoContextByParamsCKKSRNS(&_cc_params_ckksrns);
         _cc.Enable(ffi::PKESchemeFeature::PKE);
         _cc.Enable(ffi::PKESchemeFeature::KEYSWITCH);
         _cc.Enable(ffi::PKESchemeFeature::LEVELEDSHE);
@@ -1226,7 +1233,7 @@ mod tests
         let mut _index_list = CxxVector::<i32>::new();
         _index_list.pin_mut().push(1);
         _index_list.pin_mut().push(-2);
-        _cc.EvalRotateKeyGen(&_key_pair.GetPrivateKey(), &_index_list, &ffi::GenNullPublicKey());
+        _cc.EvalRotateKeyGen(&_key_pair.GetPrivateKey(), &_index_list, &ffi::DCRTPolyGenNullPublicKey());
 
         let mut _x_1 = CxxVector::<f64>::new();
         _x_1.pin_mut().push(0.25);
@@ -1248,7 +1255,7 @@ mod tests
         _x_2.pin_mut().push(0.5);
         _x_2.pin_mut().push(0.25);
 
-        let _dcrt_poly_params = ffi::GenNullDCRTPolyParams();
+        let _dcrt_poly_params = ffi::DCRTPolyGenNullParams();
         let _p_txt_1 = _cc.MakeCKKSPackedPlaintext(&_x_1, 1, 0, &_dcrt_poly_params, 0);
         let _p_txt_2 = _cc.MakeCKKSPackedPlaintext(&_x_2, 1, 0, &_dcrt_poly_params, 0);
 
@@ -1308,7 +1315,7 @@ mod tests
         _cc_params_ckksrns.pin_mut().SetMultiplicativeDepth(6);
         _cc_params_ckksrns.pin_mut().SetScalingModSize(50);
 
-        let _cc = ffi::GenCryptoContextByParamsCKKSRNS(&_cc_params_ckksrns);
+        let _cc = ffi::DCRTPolyGenCryptoContextByParamsCKKSRNS(&_cc_params_ckksrns);
         _cc.Enable(ffi::PKESchemeFeature::PKE);
         _cc.Enable(ffi::PKESchemeFeature::KEYSWITCH);
         _cc.Enable(ffi::PKESchemeFeature::LEVELEDSHE);
@@ -1373,7 +1380,7 @@ mod tests
         _coefficients_2.pin_mut().push(-0.4);
         _coefficients_2.pin_mut().push(-0.5);
 
-        let _dcrt_poly_params = ffi::GenNullDCRTPolyParams();
+        let _dcrt_poly_params = ffi::DCRTPolyGenNullParams();
         let _plain_text_1 = _cc.MakeCKKSPackedPlaintextByVectorOfComplex(&_input, 1, 0, &_dcrt_poly_params, 0);
         let _key_pair = _cc.KeyGen();
         print!("Generating evaluation key for homomorphic multiplication...");