Adding some new functions

examples/function_evaluation.rs

@@ -40,7 +40,7 @@ fn EvalLogisticExample()
     _input.pin_mut().push(ffi::ComplexPair{re: 4.0, im: 0.0});
     let _encoded_length: usize = _input.len();
     let mut _plain_text = _cc.MakeCKKSPackedPlaintextByVectorOfComplex(&_input, 1, 0, SharedPtr::<ffi::DCRTPolyParams>::null(), 0);
-    let mut _cipher_text = _cc.Encrypt(_key_pair.GetPublicKey(), &_plain_text);
+    let mut _cipher_text = _cc.EncryptByPublicKey(_key_pair.GetPublicKey(), &_plain_text);
     let _lower_bound: f64 = -5.0;
     let _upper_bound: f64 = 5.0;
     let _result = _cc.EvalLogistic(&_cipher_text, _lower_bound, _upper_bound, _poly_degree);
@@ -108,7 +108,7 @@ fn EvalFunctionExample()
 
     let _encoded_length: usize = _input.len();
     let mut _plain_text = _cc.MakeCKKSPackedPlaintextByVectorOfComplex(&_input, 1, 0, SharedPtr::<ffi::DCRTPolyParams>::null(), 0);
-    let mut _cipher_text = _cc.Encrypt(_key_pair.GetPublicKey(), &_plain_text);
+    let mut _cipher_text = _cc.EncryptByPublicKey(_key_pair.GetPublicKey(), &_plain_text);
     let _lower_bound: f64 = 0.0;
     let _upper_bound: f64 = 10.0;
     let _result = _cc.EvalChebyshevFunction(GetSqrt, &_cipher_text, _lower_bound, _upper_bound, _poly_degree);

examples/polynomial_evaluation.rs

@@ -80,7 +80,7 @@ fn main()
     print!("Generating evaluation key for homomorphic multiplication...");
     _cc.EvalMultKeyGen(_key_pair.GetPrivateKey());
     println!("Completed.\n");
-    let mut _cipher_text_1 = _cc.Encrypt(_key_pair.GetPublicKey(), &_plain_text_1);
+    let mut _cipher_text_1 = _cc.EncryptByPublicKey(_key_pair.GetPublicKey(), &_plain_text_1);
 
     let mut _start = Instant::now();
     let mut _result = _cc.EvalPoly(&_cipher_text_1, &_coefficients_1);

examples/simple_real_numbers.rs

@@ -52,13 +52,13 @@ fn main()
     println!("Input x1: {}", _p_txt_1.GetString());
     println!("Input x2: {}", _p_txt_2.GetString());
 
-    let mut _c1 = _cc.Encrypt(_key_pair.GetPublicKey(), &_p_txt_1);
-    let mut _c2 = _cc.Encrypt(_key_pair.GetPublicKey(), &_p_txt_2);
+    let mut _c1 = _cc.EncryptByPublicKey(_key_pair.GetPublicKey(), &_p_txt_1);
+    let mut _c2 = _cc.EncryptByPublicKey(_key_pair.GetPublicKey(), &_p_txt_2);
 
-    let mut _c_add = _cc.EvalAdd(&_c1, &_c2);
-    let mut _c_sub = _cc.EvalSub(&_c1, &_c2);
+    let mut _c_add = _cc.EvalAddByCiphertexts(&_c1, &_c2);
+    let mut _c_sub = _cc.EvalSubByCiphertexts(&_c1, &_c2);
     let mut _c_scalar = _cc.EvalMultByConst(&_c1, 4.0);
-    let mut _c_mul = _cc.EvalMult(&_c1, &_c2);
+    let mut _c_mul = _cc.EvalMultByCiphertexts(&_c1, &_c2);
     let mut _c_rot_1 = _cc.EvalRotate(&_c1, 1);
     let mut _c_rot_2 = _cc.EvalRotate(&_c1, -2);
 

src/bindings.cc

@@ -180,34 +180,86 @@ std::unique_ptr<Plaintext> CryptoContextDCRTPoly::MakePackedPlaintext(
     const std::vector<int64_t>& value, const size_t noiseScaleDeg,
     const uint32_t level) const
 {
-    return std::make_unique<Plaintext>(m_cryptoContextImplSharedPtr->MakePackedPlaintext(
-        value, noiseScaleDeg, level));
+    return std::make_unique<Plaintext>(m_cryptoContextImplSharedPtr->MakePackedPlaintext(value,
+        noiseScaleDeg, level));
 }
-std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::Encrypt(
-    const std::shared_ptr<lbcrypto::PublicKeyImpl<lbcrypto::DCRTPoly>> publicKey,
-    const Plaintext& plaintext) const
+std::unique_ptr<Plaintext> CryptoContextDCRTPoly::MakeStringPlaintext(const std::string& s) const
 {
-    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->Encrypt(
-        publicKey, plaintext.GetInternal()));
+    return std::make_unique<Plaintext>(m_cryptoContextImplSharedPtr->MakeStringPlaintext(s));
 }
-std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalAdd(
+std::unique_ptr<Plaintext> CryptoContextDCRTPoly::MakeCoefPackedPlaintext(
+    const std::vector<int64_t>& value, const size_t noiseScaleDeg,
+    const uint32_t level) const
+{
+    return std::make_unique<Plaintext>(m_cryptoContextImplSharedPtr->MakeCoefPackedPlaintext(value,
+        noiseScaleDeg, level));
+}
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EncryptByPublicKey(
+    const std::shared_ptr<PublicKeyImpl> publicKey, const Plaintext& plaintext) const
+{
+    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->Encrypt(publicKey,
+        plaintext.GetInternal()));
+}
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EncryptByPrivateKey(
+    const std::shared_ptr<PrivateKeyImpl> privateKey, const Plaintext& plaintext) const
+{
+    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->Encrypt(privateKey,
+        plaintext.GetInternal()));
+}
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalAddByCiphertexts(
     const CiphertextDCRTPoly& ciphertext1, const CiphertextDCRTPoly& ciphertext2) const
 {
     return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->EvalAdd(
         ciphertext1.GetInternal(), ciphertext2.GetInternal()));
 }
-std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalSub(
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalAddByPlaintext(
+    const CiphertextDCRTPoly& ciphertext, const Plaintext& plaintext) const
+{
+    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->EvalAdd(
+        ciphertext.GetInternal(), plaintext.GetInternal()));
+}
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalAddByConst(
+    const CiphertextDCRTPoly& ciphertext, const double constant) const
+{
+    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->EvalAdd(
+        ciphertext.GetInternal(), constant));
+}
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalSubByCiphertexts(
     const CiphertextDCRTPoly& ciphertext1, const CiphertextDCRTPoly& ciphertext2) const
 {
     return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->EvalSub(
         ciphertext1.GetInternal(), ciphertext2.GetInternal()));
 }
-std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalMult(
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalSubByPlaintext(
+    const CiphertextDCRTPoly& ciphertext, const Plaintext& plaintext) const
+{
+    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->EvalSub(
+        ciphertext.GetInternal(), plaintext.GetInternal()));
+}
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalSubByConst(
+    const CiphertextDCRTPoly& ciphertext, const double constant) const
+{
+    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->EvalSub(
+        ciphertext.GetInternal(), constant));
+}
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalMultByCiphertexts(
     const CiphertextDCRTPoly& ciphertext1, const CiphertextDCRTPoly& ciphertext2) const
 {
     return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->EvalMult(
         ciphertext1.GetInternal(), ciphertext2.GetInternal()));
 }
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalMultByPlaintext(
+    const CiphertextDCRTPoly& ciphertext, const Plaintext& plaintext) const
+{
+    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->EvalMult(
+        ciphertext.GetInternal(), plaintext.GetInternal()));
+}
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalMultByConst(
+    const CiphertextDCRTPoly& ciphertext, const double constant) const
+{
+    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->EvalMult(
+        ciphertext.GetInternal(), constant));
+}
 std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalMultNoRelin(
     const CiphertextDCRTPoly& ciphertext1, const CiphertextDCRTPoly& ciphertext2) const
 {
@@ -221,12 +273,6 @@ std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalMultAndRelineariz
         m_cryptoContextImplSharedPtr->EvalMultAndRelinearize(ciphertext1.GetInternal(),
         ciphertext2.GetInternal()));
 }
-std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalMultByConst(
-    const CiphertextDCRTPoly& ciphertext, const double constant) const
-{
-    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->EvalMult(
-        ciphertext.GetInternal(), constant));
-}
 std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalRotate(
     const CiphertextDCRTPoly& ciphertext, const int32_t index) const
 {
@@ -248,12 +294,14 @@ std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalChebyshevFunction
         m_cryptoContextImplSharedPtr->EvalChebyshevFunction([&](const double x){
         double result; func(x, result); return result; }, ciphertext.GetInternal(), a, b, degree));
 }
-std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalBootstrap(
-    const CiphertextDCRTPoly& ciphertext, const uint32_t numIterations,
-    const uint32_t precision) const
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalCompareSchemeSwitching(
+    const CiphertextDCRTPoly& ciphertext1, const CiphertextDCRTPoly& ciphertext2,
+    const uint32_t numCtxts, const uint32_t numSlots, const uint32_t pLWE, const double scaleSign,
+    const bool unit) const
 {
-    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->EvalBootstrap(
-        ciphertext.GetInternal(), numIterations, precision));
+    return std::make_unique<CiphertextDCRTPoly>(
+        m_cryptoContextImplSharedPtr->EvalCompareSchemeSwitching(ciphertext1.GetInternal(),
+        ciphertext2.GetInternal(), numCtxts, numSlots, pLWE, scaleSign, unit));
 }
 std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::Rescale(
     const CiphertextDCRTPoly& ciphertext) const
@@ -340,6 +388,10 @@ void CryptoContextDCRTPoly::EvalBootstrapKeyGen(const std::shared_ptr<PrivateKey
 {
     m_cryptoContextImplSharedPtr->EvalBootstrapKeyGen(privateKey, slots);
 }
+void CryptoContextDCRTPoly::EvalBootstrapPrecompute(const uint32_t slots) const
+{
+    m_cryptoContextImplSharedPtr->EvalBootstrapPrecompute(slots);
+}
 std::unique_ptr<DecryptResult> CryptoContextDCRTPoly::Decrypt(
     const std::shared_ptr<PrivateKeyImpl> privateKey,
     const CiphertextDCRTPoly& ciphertext, Plaintext& plaintext) const
@@ -385,6 +437,24 @@ std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalPoly(
     return std::make_unique<CiphertextDCRTPoly>(
         m_cryptoContextImplSharedPtr->EvalPoly(ciphertext.GetInternal(), coefficients));
 }
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::KeySwitchDown(
+    const CiphertextDCRTPoly& ciphertext) const
+{
+    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->KeySwitchDown(
+        ciphertext.GetInternal()));
+}
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::KeySwitchExt(
+    const CiphertextDCRTPoly& ciphertext, const bool addFirst) const
+{
+    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->KeySwitchExt(
+        ciphertext.GetInternal(), addFirst));
+}
+std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::Compress(
+    const CiphertextDCRTPoly& ciphertext, const uint32_t towersLeft) const
+{
+    return std::make_unique<CiphertextDCRTPoly>(m_cryptoContextImplSharedPtr->Compress(
+        ciphertext.GetInternal(), towersLeft));
+}
 std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::EvalNegate(
     const CiphertextDCRTPoly& ciphertext) const
 {
@@ -407,7 +477,8 @@ std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::ComposedEvalMult(
     const CiphertextDCRTPoly& ciphertext1, const CiphertextDCRTPoly& ciphertext2) const
 {
     return std::make_unique<CiphertextDCRTPoly>(
-        m_cryptoContextImplSharedPtr->ComposedEvalMult(ciphertext1.GetInternal(), ciphertext2.GetInternal()));
+        m_cryptoContextImplSharedPtr->ComposedEvalMult(ciphertext1.GetInternal(),
+        ciphertext2.GetInternal()));
 }
 std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::Relinearize(
     const CiphertextDCRTPoly& ciphertext) const
@@ -415,6 +486,66 @@ std::unique_ptr<CiphertextDCRTPoly> CryptoContextDCRTPoly::Relinearize(
     return std::make_unique<CiphertextDCRTPoly>(
         m_cryptoContextImplSharedPtr->Relinearize(ciphertext.GetInternal()));
 }
+std::unique_ptr<std::vector<uint32_t>> CryptoContextDCRTPoly::FindAutomorphismIndices(
+    const std::vector<uint32_t>& idxList) const
+{
+    return std::make_unique<std::vector<uint32_t>>(
+        m_cryptoContextImplSharedPtr->FindAutomorphismIndices(idxList));
+}
+std::shared_ptr<CryptoContextImpl> CryptoContextDCRTPoly::GetInternal() const
+{
+    return m_cryptoContextImplSharedPtr;
+}
+
+// cxx currently does not support static class methods
+void ClearEvalMultKeys()
+{
+    CryptoContextImpl::ClearEvalMultKeys();
+}
+void ClearEvalMultKeysById(const std::string& id)
+{
+    CryptoContextImpl::ClearEvalMultKeys(id);
+}
+void ClearEvalMultKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext)
+{
+    CryptoContextImpl::ClearEvalMultKeys(cryptoContext.GetInternal());
+}
+void ClearEvalSumKeys()
+{
+    CryptoContextImpl::ClearEvalSumKeys();
+}
+void ClearEvalSumKeysById(const std::string& id)
+{
+    CryptoContextImpl::ClearEvalSumKeys(id);
+}
+void ClearEvalSumKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext)
+{
+    CryptoContextImpl::ClearEvalSumKeys(cryptoContext.GetInternal());
+}
+void ClearEvalAutomorphismKeys()
+{
+    CryptoContextImpl::ClearEvalAutomorphismKeys();
+}
+void ClearEvalAutomorphismKeysById(const std::string& id)
+{
+    CryptoContextImpl::ClearEvalAutomorphismKeys(id);
+}
+void ClearEvalAutomorphismKeysByCryptoContext(const CryptoContextDCRTPoly& cryptoContext)
+{
+    CryptoContextImpl::ClearEvalAutomorphismKeys(cryptoContext.GetInternal());
+}
+std::unique_ptr<std::vector<uint32_t>> GetExistingEvalAutomorphismKeyIndices(
+    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)
+{
+    return std::make_unique<std::vector<uint32_t>>(
+        CryptoContextImpl::GetUniqueValues(oldValues, newValues));
+}
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 

src/bindings.hpp

@@ -177,24 +177,42 @@ public:
         const double a, const double b, const uint32_t degree) const;
     [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalCos(const CiphertextDCRTPoly& ciphertext,
         const double a, const double b, const uint32_t degree) const;
-    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> Encrypt(
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EncryptByPublicKey(
         const std::shared_ptr<PublicKeyImpl> publicKey, const Plaintext& plaintext) const;
-    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalAdd(
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EncryptByPrivateKey(
+        const std::shared_ptr<PrivateKeyImpl> privateKey, const Plaintext& plaintext) const;
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalAddByCiphertexts(
         const CiphertextDCRTPoly& ciphertext1, const CiphertextDCRTPoly& ciphertext2) const;
-    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalSub(
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalAddByPlaintext(
+        const CiphertextDCRTPoly& ciphertext, const Plaintext& plaintext) const;
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalAddByConst(
+        const CiphertextDCRTPoly& ciphertext, const double constant) const;
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalSubByCiphertexts(
         const CiphertextDCRTPoly& ciphertext1, const CiphertextDCRTPoly& ciphertext2) const;
-    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalMult(
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalSubByPlaintext(
+        const CiphertextDCRTPoly& ciphertext, const Plaintext& plaintext) const;
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalSubByConst(
+        const CiphertextDCRTPoly& ciphertext, const double constant) const;
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalMultByCiphertexts(
         const CiphertextDCRTPoly& ciphertext1, const CiphertextDCRTPoly& ciphertext2) const;
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalMultByPlaintext(
+        const CiphertextDCRTPoly& ciphertext, const Plaintext& plaintext) const;
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalMultByConst(
+        const CiphertextDCRTPoly& ciphertext, const double constant) const;
     [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalMultNoRelin(
         const CiphertextDCRTPoly& ciphertext1, const CiphertextDCRTPoly& ciphertext2) const;
     [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalMultAndRelinearize(
         const CiphertextDCRTPoly& ciphertext1, const CiphertextDCRTPoly& ciphertext2) const;
-    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalMultByConst(
-        const CiphertextDCRTPoly& ciphertext, const double constant) const;
     [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalRotate(
         const CiphertextDCRTPoly& ciphertext, const int32_t index) const;
     [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalPoly(
         const CiphertextDCRTPoly& ciphertext, const std::vector<double>& coefficients) const;
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> KeySwitchDown(
+        const CiphertextDCRTPoly& ciphertext) const;
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> KeySwitchExt(
+        const CiphertextDCRTPoly& ciphertext, const bool addFirst) const;
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> Compress(
+        const CiphertextDCRTPoly& ciphertext, const uint32_t towersLeft /* 1 */) const;
     [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalNegate(
         const CiphertextDCRTPoly& ciphertext) const;
     [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalSquare(
@@ -240,17 +258,27 @@ public:
         const uint32_t degree) const;
     [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> IntMPBootRandomElementGen(
         const PublicKeyDCRTPoly& publicKey) const;
+    [[nodiscard]] std::unique_ptr<CiphertextDCRTPoly> EvalCompareSchemeSwitching(
+        const CiphertextDCRTPoly& ciphertext1, const CiphertextDCRTPoly& ciphertext2,
+        const uint32_t numCtxts /* 0 */, const uint32_t numSlots /* 0 */,
+        const uint32_t pLWE /* 0 */, const double scaleSign /* 1.0 */,
+        const bool unit /* false */) const;
     void EvalBootstrapSetup(const std::vector<uint32_t>& levelBudget /* {5, 4} */,
         const std::vector<uint32_t>& dim1 /* {0, 0} */, const uint32_t slots /* 0 */,
         const uint32_t correctionFactor /* 0 */, const bool precompute /* true */) const;
     void EvalBootstrapKeyGen(const std::shared_ptr<PrivateKeyImpl> privateKey,
         const uint32_t slots) const;
+    void EvalBootstrapPrecompute(const uint32_t slots /* 0 */) const;
     [[nodiscard]] std::unique_ptr<DecryptResult> Decrypt(
         const std::shared_ptr<PrivateKeyImpl> privateKey, const CiphertextDCRTPoly& ciphertext,
         Plaintext& plaintext) const;
     [[nodiscard]] std::unique_ptr<Plaintext> MakePackedPlaintext(
         const std::vector<int64_t>& value, const size_t noiseScaleDeg /* 1 */,
         const uint32_t level /* 0 */) const;
+    [[nodiscard]] std::unique_ptr<Plaintext> MakeStringPlaintext(const std::string& s) const;
+    [[nodiscard]] std::unique_ptr<Plaintext> MakeCoefPackedPlaintext(
+        const std::vector<int64_t>& value, const size_t noiseScaleDeg /* 1 */,
+        const uint32_t level /* 0 */) const;
     [[nodiscard]] std::unique_ptr<Plaintext> MakeCKKSPackedPlaintext(
         const std::vector<double>& value, const size_t scaleDeg /* 1 */,
         const uint32_t level /* 0 */, const std::shared_ptr<DCRTPolyParams> params /* nullptr */,
@@ -259,7 +287,25 @@ public:
         const std::vector<ComplexPair>& value, const size_t scaleDeg /* 1 */,
         const uint32_t level /* 0 */, const std::shared_ptr<DCRTPolyParams> params /* nullptr */,
         const uint32_t slots /* 0 */) const;
+    [[nodiscard]] std::unique_ptr<std::vector<uint32_t>> FindAutomorphismIndices(
+        const std::vector<uint32_t>& idxList) const;
+    [[nodiscard]] std::shared_ptr<CryptoContextImpl> GetInternal() const;
 };
+// 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(
+    const std::string& keyTag);
+[[nodiscard]] std::unique_ptr<std::vector<uint32_t>> GetUniqueValues(
+    const std::vector<uint32_t>& oldValues,
+    const std::vector<uint32_t>& newValues);
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 

src/lib.rs

@@ -497,22 +497,33 @@ pub mod ffi
         fn MakePackedPlaintext(self: &CryptoContextDCRTPoly, value: &CxxVector<i64>,
                                noiseScaleDeg: /* 1 */ usize, level: /* 0 */ u32)
                                -> UniquePtr<Plaintext>;
-        fn Encrypt(self: &CryptoContextDCRTPoly, publicKey: SharedPtr<PublicKeyImpl>,
-                   plaintext: &Plaintext) -> UniquePtr<CiphertextDCRTPoly>;
-        fn EvalAdd(self: &CryptoContextDCRTPoly, ciphertext1: &CiphertextDCRTPoly,
-                   ciphertext2: &CiphertextDCRTPoly) -> UniquePtr<CiphertextDCRTPoly>;
-        fn EvalSub(self: &CryptoContextDCRTPoly, ciphertext1: &CiphertextDCRTPoly,
-                   ciphertext2: &CiphertextDCRTPoly) -> UniquePtr<CiphertextDCRTPoly>;
-        fn EvalMult(self: &CryptoContextDCRTPoly, ciphertext1: &CiphertextDCRTPoly,
-                    ciphertext2: &CiphertextDCRTPoly) -> UniquePtr<CiphertextDCRTPoly>;
+        fn EncryptByPublicKey(self: &CryptoContextDCRTPoly, publicKey: SharedPtr<PublicKeyImpl>,
+                              plaintext: &Plaintext) -> UniquePtr<CiphertextDCRTPoly>;
+        fn EncryptByPrivateKey(self: &CryptoContextDCRTPoly, privateKey: SharedPtr<PrivateKeyImpl>,
+                               plaintext: &Plaintext) -> UniquePtr<CiphertextDCRTPoly>;
+        fn EvalAddByCiphertexts(self: &CryptoContextDCRTPoly, ciphertext1: &CiphertextDCRTPoly,
+                                ciphertext2: &CiphertextDCRTPoly) -> UniquePtr<CiphertextDCRTPoly>;
+        fn EvalAddByPlaintext(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly,
+                              plaintext: &Plaintext) -> UniquePtr<CiphertextDCRTPoly>;
+        fn EvalAddByConst(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly,
+                          constant: f64) -> UniquePtr<CiphertextDCRTPoly>;
+        fn EvalSubByCiphertexts(self: &CryptoContextDCRTPoly, ciphertext1: &CiphertextDCRTPoly,
+                                ciphertext2: &CiphertextDCRTPoly) -> UniquePtr<CiphertextDCRTPoly>;
+        fn EvalSubByPlaintext(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly,
+                              plaintext: &Plaintext) -> UniquePtr<CiphertextDCRTPoly>;
+        fn EvalSubByConst(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly,
+                          constant: f64) -> UniquePtr<CiphertextDCRTPoly>;
+        fn EvalMultByCiphertexts(self: &CryptoContextDCRTPoly, ciphertext1: &CiphertextDCRTPoly,
+                                 ciphertext2: &CiphertextDCRTPoly) -> UniquePtr<CiphertextDCRTPoly>;
+        fn EvalMultByPlaintext(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly,
+                               plaintext: &Plaintext) -> UniquePtr<CiphertextDCRTPoly>;
+        fn EvalMultByConst(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly,
+                           constant: f64) -> UniquePtr<CiphertextDCRTPoly>;
         fn EvalMultNoRelin(self: &CryptoContextDCRTPoly, ciphertext1: &CiphertextDCRTPoly,
                            ciphertext2: &CiphertextDCRTPoly) -> UniquePtr<CiphertextDCRTPoly>;
-        fn EvalMultAndRelinearize(self: &CryptoContextDCRTPoly,
-                                  ciphertext1: &CiphertextDCRTPoly,
+        fn EvalMultAndRelinearize(self: &CryptoContextDCRTPoly, ciphertext1: &CiphertextDCRTPoly,
                                   ciphertext2: &CiphertextDCRTPoly)
                                   -> UniquePtr<CiphertextDCRTPoly>;
-        fn EvalMultByConst(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly,
-                           constant: f64) -> UniquePtr<CiphertextDCRTPoly>;
         fn EvalRotate(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly, index: i32)
                       -> UniquePtr<CiphertextDCRTPoly>;
         fn EvalChebyshevSeries(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly,
@@ -547,6 +558,10 @@ pub mod ffi
                    -> UniquePtr<DecryptResult>;
         fn GetRingDimension(self: &CryptoContextDCRTPoly) -> u32;
         fn GetCyclotomicOrder(self: &CryptoContextDCRTPoly) -> u32;
+        fn MakeStringPlaintext(self: &CryptoContextDCRTPoly, s: &CxxString) -> UniquePtr<Plaintext>;
+        fn MakeCoefPackedPlaintext(self: &CryptoContextDCRTPoly, value: &CxxVector<i64>,
+                                   noiseScaleDeg: /* 1 */ usize, level: /* 0 */ u32)
+                                   -> UniquePtr<Plaintext>;
         fn MakeCKKSPackedPlaintext(self: &CryptoContextDCRTPoly, value: &CxxVector<f64>,
                                    scaleDeg: /* 1 */ usize, level: /* 0 */ u32,
                                    params: /* null() */ SharedPtr<DCRTPolyParams>,
@@ -595,6 +610,35 @@ pub mod ffi
                             ciphertext2: &CiphertextDCRTPoly) -> UniquePtr<CiphertextDCRTPoly>;
         fn Relinearize(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly)
                        -> UniquePtr<CiphertextDCRTPoly>;
+        fn KeySwitchDown(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly)
+                         -> UniquePtr<CiphertextDCRTPoly>;
+        fn KeySwitchExt(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly,
+                        addFirst: bool) -> UniquePtr<CiphertextDCRTPoly>;
+        fn Compress(self: &CryptoContextDCRTPoly, ciphertext: &CiphertextDCRTPoly,
+                    towersLeft: /* 1 */ u32) -> UniquePtr<CiphertextDCRTPoly>;
+        fn EvalCompareSchemeSwitching(self: &CryptoContextDCRTPoly,
+                                      ciphertext1: &CiphertextDCRTPoly,
+                                      ciphertext2: &CiphertextDCRTPoly, numCtxts: /* 0 */ u32,
+                                      numSlots: /* 0 */ u32, pLWE: /* 0 */ u32,
+                                      scaleSign: /* 1.0 */ f64, unit: /* false */ bool)
+                                      -> UniquePtr<CiphertextDCRTPoly>;
+        fn EvalBootstrapPrecompute(self: &CryptoContextDCRTPoly, slots: /* 0 */ u32);
+        fn FindAutomorphismIndices(self: &CryptoContextDCRTPoly, idxList: &CxxVector<u32>)
+                                   -> UniquePtr<CxxVector<u32>>;
+
+        // cxx currently does not support static class methods
+        fn ClearEvalMultKeys();
+        fn ClearEvalMultKeysById(id: &CxxString);
+        fn ClearEvalMultKeysByCryptoContext(cryptoContext: &CryptoContextDCRTPoly);
+        fn ClearEvalSumKeys();
+        fn ClearEvalSumKeysById(id: &CxxString);
+        fn ClearEvalSumKeysByCryptoContext(cryptoContext: &CryptoContextDCRTPoly);
+        fn ClearEvalAutomorphismKeys();
+        fn ClearEvalAutomorphismKeysById(id: &CxxString);
+        fn ClearEvalAutomorphismKeysByCryptoContext(cryptoContext: &CryptoContextDCRTPoly);
+        fn GetExistingEvalAutomorphismKeyIndices(keyTag: &CxxString) -> UniquePtr<CxxVector<u32>>;
+        fn GetUniqueValues(oldValues: &CxxVector<u32>, newValues: &CxxVector<u32>)
+                           -> UniquePtr<CxxVector<u32>>;
     }
 
     // Serialize / Deserialize
@@ -714,15 +758,15 @@ mod tests
         _vector_of_ints_3.pin_mut().push(12);
         let mut _plain_text_3 = _cc.MakePackedPlaintext(&_vector_of_ints_3, 1, 0);
 
-        let mut _cipher_text_1 = _cc.Encrypt(_key_pair.GetPublicKey(), &_plain_text_1);
-        let mut _cipher_text_2 = _cc.Encrypt(_key_pair.GetPublicKey(), &_plain_text_2);
-        let mut _cipher_text_3 = _cc.Encrypt(_key_pair.GetPublicKey(), &_plain_text_3);
+        let mut _cipher_text_1 = _cc.EncryptByPublicKey(_key_pair.GetPublicKey(), &_plain_text_1);
+        let mut _cipher_text_2 = _cc.EncryptByPublicKey(_key_pair.GetPublicKey(), &_plain_text_2);
+        let mut _cipher_text_3 = _cc.EncryptByPublicKey(_key_pair.GetPublicKey(), &_plain_text_3);
 
-        let mut _cipher_text_add_1_2 = _cc.EvalAdd(&_cipher_text_1, &_cipher_text_2);
-        let mut _cipher_text_add_result = _cc.EvalAdd(&_cipher_text_add_1_2, &_cipher_text_3);
+        let mut _cipher_text_add_1_2 = _cc.EvalAddByCiphertexts(&_cipher_text_1, &_cipher_text_2);
+        let mut _cipher_text_add_result = _cc.EvalAddByCiphertexts(&_cipher_text_add_1_2, &_cipher_text_3);
 
-        let mut _cipher_text_mul_1_2 = _cc.EvalMult(&_cipher_text_1, &_cipher_text_2);
-        let mut _cipher_text_mult_result = _cc.EvalMult(&_cipher_text_mul_1_2, &_cipher_text_3);
+        let mut _cipher_text_mul_1_2 = _cc.EvalMultByCiphertexts(&_cipher_text_1, &_cipher_text_2);
+        let mut _cipher_text_mult_result = _cc.EvalMultByCiphertexts(&_cipher_text_mul_1_2, &_cipher_text_3);
 
         let mut _cipher_text_rot_1 = _cc.EvalRotate(&_cipher_text_1, 1);
         let mut _cipher_text_rot_2 = _cc.EvalRotate(&_cipher_text_1, 2);
@@ -812,13 +856,13 @@ mod tests
         println!("Input x1: {}", _p_txt_1.GetString());
         println!("Input x2: {}", _p_txt_2.GetString());
 
-        let mut _c1 = _cc.Encrypt(_key_pair.GetPublicKey(), &_p_txt_1);
-        let mut _c2 = _cc.Encrypt(_key_pair.GetPublicKey(), &_p_txt_2);
+        let mut _c1 = _cc.EncryptByPublicKey(_key_pair.GetPublicKey(), &_p_txt_1);
+        let mut _c2 = _cc.EncryptByPublicKey(_key_pair.GetPublicKey(), &_p_txt_2);
 
-        let mut _c_add = _cc.EvalAdd(&_c1, &_c2);
-        let mut _c_sub = _cc.EvalSub(&_c1, &_c2);
+        let mut _c_add = _cc.EvalAddByCiphertexts(&_c1, &_c2);
+        let mut _c_sub = _cc.EvalSubByCiphertexts(&_c1, &_c2);
         let mut _c_scalar = _cc.EvalMultByConst(&_c1, 4.0);
-        let mut _c_mul = _cc.EvalMult(&_c1, &_c2);
+        let mut _c_mul = _cc.EvalMultByCiphertexts(&_c1, &_c2);
         let mut _c_rot_1 = _cc.EvalRotate(&_c1, 1);
         let mut _c_rot_2 = _cc.EvalRotate(&_c1, -2);
 
@@ -935,7 +979,7 @@ mod tests
         print!("Generating evaluation key for homomorphic multiplication...");
         _cc.EvalMultKeyGen(_key_pair.GetPrivateKey());
         println!("Completed.\n");
-        let mut _cipher_text_1 = _cc.Encrypt(_key_pair.GetPublicKey(), &_plain_text_1);
+        let mut _cipher_text_1 = _cc.EncryptByPublicKey(_key_pair.GetPublicKey(), &_plain_text_1);
 
         let mut _start = Instant::now();
         let mut _result = _cc.EvalPoly(&_cipher_text_1, &_coefficients_1);