*= operator for Ctxt for constant multiplication (#259)

Author: Jack L Crawford

include/helib/Ctxt.h

@@ -1,4 +1,4 @@
-/* Copyright (C) 2012-2019 IBM Corp.
+/* Copyright (C) 2012-2020 IBM Corp.
  * This program is Licensed under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance
  * with the License. You may obtain a copy of the License at
@@ -357,7 +357,7 @@ class Ctxt {
   ///@{
   void negate();
 
- // Add/subtract aonther ciphertext
+ // Add/subtract another ciphertext
   Ctxt& operator+=(const Ctxt& other) { addCtxt(other); return *this; }
   Ctxt& operator-=(const Ctxt& other) { addCtxt(other,true); return *this; }
   void addCtxt(const Ctxt& other, bool negative=false);
@@ -424,6 +424,20 @@ class Ctxt {
    **/
   Ctxt& operator*=(const helib::Ptxt<helib::CKKS>& other);
 
+  /**
+   * @brief Times equals operator with a `ZZX`.
+   * @param poly Element by which to multiply.
+   * @return Reference to `*this` post multiplication.
+   **/
+  Ctxt& operator*=(const NTL::ZZX& poly);
+
+  /**
+   * @brief Times equals oeprator with a `long`.
+   * @param scalar Constant by which to multiply.
+   * @return Reference to `*this` post multiplication.
+   **/
+  Ctxt& operator*=(const long scalar);
+
   //! Add a constant polynomial. 
   //! If provided, size should be a high-probability bound
   //! on the L-infty norm of the canonical embedding

include/helib/Ptxt.h

@@ -1,4 +1,4 @@
-/* Copyright (C) 2019 IBM Corp.
+/* Copyright (C) 2019-2020 IBM Corp.
  * This program is Licensed under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance
  * with the License. You may obtain a copy of the License at

src/Ctxt.cpp

@@ -1,4 +1,4 @@
-/* Copyright (C) 2012-2019 IBM Corp.
+/* Copyright (C) 2012-2020 IBM Corp.
  * This program is Licensed under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance
  * with the License. You may obtain a copy of the License at
@@ -863,6 +863,20 @@ Ctxt& Ctxt::operator*=(const helib::Ptxt<helib::CKKS>& other)
   return *this;
 }
 
+Ctxt& Ctxt::operator*=(const NTL::ZZX& poly)
+{
+  if(isCKKS())
+    multByConstantCKKS(poly);
+  else
+    multByConstant(poly);
+  return *this;
+}
+
+Ctxt& Ctxt::operator*=(const long scalar)
+{
+  return *this *= NTL::ZZX(scalar);
+}
+
 void Ctxt::addConstantCKKS(const std::vector<std::complex<double>>& other)
 {
   NTL::ZZX poly;

tests/CMakeLists.txt

@@ -7,6 +7,7 @@ set(GTEST_SRC
     "TestArgMap.cpp"
     "TestBootstrappingWithMultiplications.cpp"
     "TestContext.cpp"
+    "TestCtxt.cpp"
     "TestPolyMod.cpp"
     "TestPtxt.cpp"
     "TestPolyModRing.cpp")
@@ -72,6 +73,7 @@ set(TEST_NAMES
     "TestArgMap"
     "TestCKKS"
     "TestContext"
+    "TestCtxt"
     "TestErrorHandling"
     "TestFatBootstrappingWithMultiplications"
     "TestThinBootstrappingWithMultiplications"

tests/TestCtxt.cpp

@@ -0,0 +1,106 @@
+/* Copyright (C) 2020 IBM Corp.
+ * This program is Licensed under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License. See accompanying LICENSE file.
+ */
+
+// This test file does not fully cover Ctxt, and is intended as a starting
+// point for testing new functionality of Ctxt going forward.
+// The older tests with more extensive coverage can be found in the files
+// with names matching "GTest*".
+
+#include <helib/helib.h>
+
+#include "test_common.h"
+#include "gtest/gtest.h"
+
+namespace {
+
+struct BGVParameters
+{
+  BGVParameters(unsigned m, unsigned p, unsigned r, unsigned bits) :
+      m(m),
+      p(p),
+      r(r),
+      bits(bits){};
+
+  const unsigned m;
+  const unsigned p;
+  const unsigned r;
+  const unsigned bits;
+
+  friend std::ostream& operator<<(std::ostream& os, const BGVParameters& params)
+  {
+    return os << "{"
+              << "m = " << params.m << ", "
+              << "p = " << params.p << ", "
+              << "r = " << params.r << ", "
+              << "bits = " << params.bits << "}";
+  }
+};
+
+class TestCtxt : public ::testing::TestWithParam<BGVParameters>
+{
+protected:
+  const unsigned long m;
+  const unsigned long p;
+  const unsigned long r;
+  const unsigned long bits;
+  helib::Context context;
+  helib::SecKey secretKey;
+  helib::PubKey publicKey;
+  const helib::EncryptedArray& ea;
+
+  TestCtxt() :
+      m(GetParam().m),
+      p(GetParam().p),
+      r(GetParam().r),
+      bits(GetParam().bits),
+      context(m, p, r),
+      secretKey((buildModChain(context, bits), context)),
+      publicKey((secretKey.GenSecKey(), secretKey)),
+      ea(*(context.ea))
+  {}
+};
+
+TEST_P(TestCtxt, timesEqualsWithLongWorks)
+{
+  helib::Ptxt<helib::BGV> ptxt(context, std::vector<long>(ea.size(), 5));
+  helib::Ctxt ctxt(publicKey);
+  publicKey.Encrypt(ctxt, ptxt);
+  ctxt *= 2l;
+
+  helib::Ptxt<helib::BGV> expected_result(context,
+                                          std::vector<long>(ea.size(), 10));
+  helib::Ptxt<helib::BGV> decrypted_result(context);
+  secretKey.Decrypt(decrypted_result, ctxt);
+
+  EXPECT_EQ(decrypted_result, expected_result);
+}
+
+TEST_P(TestCtxt, timesEqualsWithZZXWorks)
+{
+  helib::Ptxt<helib::BGV> ptxt(context, std::vector<long>(ea.size(), 5));
+  helib::Ctxt ctxt(publicKey);
+  publicKey.Encrypt(ctxt, ptxt);
+  ctxt *= NTL::ZZX(2l);
+
+  helib::Ptxt<helib::BGV> expected_result(context,
+                                          std::vector<long>(ea.size(), 10));
+  helib::Ptxt<helib::BGV> decrypted_result(context);
+  secretKey.Decrypt(decrypted_result, ctxt);
+
+  EXPECT_EQ(decrypted_result, expected_result);
+}
+
+INSTANTIATE_TEST_SUITE_P(variousParameters,
+                         TestCtxt,
+                         ::testing::Values(BGVParameters(17, 2, 1, 100)));
+
+} // namespace