Pass integer parameter by value to function instead of by constant reference

dsuponitskiy-duality · dsuponitskiy-duality · commit a3eea2e600a2 · 2026-04-15T14:20:10.000-04:00
diff --git a/benchmark/src/IntegerMath.cpp b/benchmark/src/IntegerMath.cpp
@@ -187,7 +187,7 @@ static void BM_BigInt_DividedByEq(benchmark::State& state) {
 }
 
 template <typename I>
-static void exp_BigInt(const I& a, const uint32_t& b) {
+static void exp_BigInt(const I& a, uint32_t b) {
     __attribute__((unused)) I c1 = a.Exp(b);
 }
 
@@ -199,7 +199,7 @@ static void BM_BigInt_Exp(benchmark::State& state) {
 }
 
 template <typename I>
-static void expeq_BigInt(I a, const uint32_t& b) {
+static void expeq_BigInt(I a, uint32_t b) {
     a.ExpEq(b);
 }
 
@@ -239,7 +239,7 @@ static void BM_BigInt_MultiplyAndRoundEq(benchmark::State& state) {
 }
 
 template <typename I>
-static void lshift_BigInt(const I& a, const uint16_t& b) {
+static void lshift_BigInt(const I& a, uint16_t b) {
     __attribute__((unused)) I c1 = a.LShift(b);
 }
 
@@ -251,7 +251,7 @@ static void BM_BigInt_LShift(benchmark::State& state) {
 }
 
 template <typename I>
-static void lshifteq_BigInt(I a, const uint16_t& b) {
+static void lshifteq_BigInt(I a, uint16_t b) {
     a.LShiftEq(b);
 }
 
@@ -263,7 +263,7 @@ static void BM_BigInt_LShiftEq(benchmark::State& state) {
 }
 
 template <typename I>
-static void rshift_BigInt(const I& a, const uint16_t& b) {
+static void rshift_BigInt(const I& a, uint16_t b) {
     __attribute__((unused)) I c1 = a.RShift(b);
 }
 
@@ -275,7 +275,7 @@ static void BM_BigInt_RShift(benchmark::State& state) {
 }
 
 template <typename I>
-static void rshifteq_BigInt(I a, const uint16_t& b) {
+static void rshifteq_BigInt(I a, uint16_t b) {
     a.RShiftEq(b);
 }
 
diff --git a/benchmark/src/ckks-functional-bootstrapping.cpp b/benchmark/src/ckks-functional-bootstrapping.cpp
@@ -338,7 +338,7 @@ struct fbt_config {
 
     auto exact(x);
     std::transform(x.begin(), x.end(), exact.begin(),
-                   [&](const int64_t& elem) { return (elem >= t.PInput.ConvertToDouble() / 2.); });
+                   [&](int64_t elem) { return (elem >= t.PInput.ConvertToDouble() / 2.); });
 
     std::vector<int64_t> coeffintMod;
     std::vector<std::complex<double>> coeffcompMod;
diff --git a/src/core/extras/math.cpp b/src/core/extras/math.cpp
@@ -71,7 +71,7 @@ int main(int argc, char* argv[]) {
     do {                                                                                                 \
         try {                                                                                            \
             TIC(t);                                                                                      \
-            for (uint32_t j = 0; j < nloop; j++) {                                                          \
+            for (uint32_t j = 0; j < nloop; j++) {                                                       \
                 res = (fn);                                                                              \
             }                                                                                            \
             time2 = TOC(t);                                                                              \
diff --git a/src/core/extras/ntt1.cpp b/src/core/extras/ntt1.cpp
@@ -66,7 +66,7 @@ int main(int argc, char* argv[]) {
     do {                                                                                                    \
         try {                                                                                               \
             TIC(t);                                                                                         \
-            for (uint32_t j = 0; j < nloop; j++) {                                                             \
+            for (uint32_t j = 0; j < nloop; j++) {                                                          \
                 res = (fn);                                                                                 \
             }                                                                                               \
             time2 = TOC(t);                                                                                 \
diff --git a/src/core/include/lattice/hal/dcrtpoly-interface.h b/src/core/include/lattice/hal/dcrtpoly-interface.h
@@ -1299,7 +1299,7 @@ class DCRTPolyInterface : public ILElement<DerivedType, BigVecType> {
         const std::vector<NativeInteger>& mtildeQHatInvModq, const std::vector<NativeInteger>& mtildeQHatInvModqPrecon,
         const std::vector<std::vector<NativeInteger>>& QHatModbsk, const std::vector<uint64_t>& QHatModmtilde,
         const std::vector<NativeInteger>& QModbsk, const std::vector<NativeInteger>& QModbskPrecon,
-        const uint64_t& negQInvModmtilde, const std::vector<NativeInteger>& mtildeInvModbsk,
+        uint64_t negQInvModmtilde, const std::vector<NativeInteger>& mtildeInvModbsk,
         const std::vector<NativeInteger>& mtildeInvModbskPrecon) = 0;
 
     /**
diff --git a/src/core/include/lattice/hal/default/dcrtpoly-impl.h b/src/core/include/lattice/hal/default/dcrtpoly-impl.h
@@ -1517,7 +1517,7 @@ DCRTPolyImpl<VecType> DCRTPolyImpl<VecType>::ScaleAndRound(
         OPENFHE_THROW("Use of ScaleAndRound with NATIVEINT == 32 may lead to overflow");
 
     DCRTPolyImpl<VecType> ans(paramsOutput, m_format, true);
-    uint32_t ringDim   = m_params->GetRingDimension();
+    uint32_t ringDim     = m_params->GetRingDimension();
     uint32_t sizeQP      = m_vectors.size();
     uint32_t sizeO       = ans.m_vectors.size();
     uint32_t sizeI       = sizeQP - sizeO;
@@ -1697,7 +1697,7 @@ void DCRTPolyImpl<VecType>::FastBaseConvqToBskMontgomery(
     const std::vector<NativeInteger>& mtildeQHatInvModq, const std::vector<NativeInteger>& mtildeQHatInvModqPrecon,
     const std::vector<std::vector<NativeInteger>>& QHatModbsk, const std::vector<uint64_t>& QHatModmtilde,
     const std::vector<NativeInteger>& QModbsk, const std::vector<NativeInteger>& QModbskPrecon,
-    const uint64_t& negQInvModmtilde, const std::vector<NativeInteger>& mtildeInvModbsk,
+    uint64_t negQInvModmtilde, const std::vector<NativeInteger>& mtildeInvModbsk,
     const std::vector<NativeInteger>& mtildeInvModbskPrecon) {
     constexpr uint64_t mtilde         = (uint64_t)1 << 16;
     constexpr uint64_t mtilde_half    = mtilde >> 1;
diff --git a/src/core/include/lattice/hal/default/dcrtpoly.h b/src/core/include/lattice/hal/default/dcrtpoly.h
@@ -307,7 +307,7 @@ class DCRTPolyImpl final : public DCRTPolyInterface<DCRTPolyImpl<VecType>, VecTy
         const std::vector<NativeInteger>& mtildeQHatInvModq, const std::vector<NativeInteger>& mtildeQHatInvModqPrecon,
         const std::vector<std::vector<NativeInteger>>& QHatModbsk, const std::vector<uint64_t>& QHatModmtilde,
         const std::vector<NativeInteger>& QModbsk, const std::vector<NativeInteger>& QModbskPrecon,
-        const uint64_t& negQInvModmtilde, const std::vector<NativeInteger>& mtildeInvModbsk,
+        uint64_t negQInvModmtilde, const std::vector<NativeInteger>& mtildeInvModbsk,
         const std::vector<NativeInteger>& mtildeInvModbskPrecon) override;
 
     void FastRNSFloorq(const NativeInteger& t, const std::vector<NativeInteger>& moduliQ,
diff --git a/src/core/include/math/hal/bigintdyn/mubintvecdyn.h b/src/core/include/math/hal/bigintdyn/mubintvecdyn.h
@@ -96,7 +96,7 @@ class mubintvec final : public lbcrypto::BigVectorInterface<mubintvec<ubint_el_t
    * @param modulus uint32_t associated with entries in the vector.
    */
     // TODO: what practical purpose with uint32_t modulus??
-    //    explicit mubintvec(uint32_t length, const uint32_t& modulus) noexcept
+    //    explicit mubintvec(uint32_t length, uint32_t modulus) noexcept
     //        : m_modulus(modulus), m_modulus_state(State::INITIALIZED), m_data(length) {}
 
     /**
@@ -269,7 +269,7 @@ class mubintvec final : public lbcrypto::BigVectorInterface<mubintvec<ubint_el_t
    *
    * @param value is the value to set.
    */
-    //    void SetModulus(const uint32_t& value) noexcept {
+    //    void SetModulus(uint32_t value) noexcept {
     //        m_modulus       = ubint_el_t(value);
     //        m_modulus_state = State::INITIALIZED;
     //    }
diff --git a/src/core/include/math/hal/bigintntl/mubintvecntl.h b/src/core/include/math/hal/bigintntl/mubintvecntl.h
@@ -195,7 +195,7 @@ class myVecP : public NTL::Vec<myT>,
     }
 
     // sets modulus and the NTL init function uint64_t argument
-    inline void SetModulus(const uint64_t& value) {
+    inline void SetModulus(uint64_t value) {
         if (value == 0) {
             OPENFHE_THROW("SetModulus(uint64_t) cannot be zero");
         }
diff --git a/src/pke/examples/functional-bootstrapping-ckks.cpp b/src/pke/examples/functional-bootstrapping-ckks.cpp
@@ -230,13 +230,13 @@ void ArbitraryLUT(BigInteger QBFVInit, BigInteger PInput, BigInteger POutput, Bi
     std::cerr << "]" << std::endl;
 
     auto exact(x);
-    std::transform(x.begin(), x.end(), exact.begin(), [&](const int64_t& elem) {
+    std::transform(x.begin(), x.end(), exact.begin(), [&](int64_t elem) {
         return (func(elem) > POutput.ConvertToDouble() / 2.) ? func(elem) - POutput.ConvertToInt() : func(elem);
     });
 
     std::transform(exact.begin(), exact.end(), computed.begin(), exact.begin(), std::minus<int64_t>());
     std::transform(exact.begin(), exact.end(), exact.begin(),
-                   [&](const int64_t& elem) { return (std::abs(elem)) % (POutput.ConvertToInt()); });
+                   [&](int64_t elem) { return (std::abs(elem)) % (POutput.ConvertToInt()); });
     auto max_error_it = std::max_element(exact.begin(), exact.end());
     std::cerr << "Max absolute error obtained: " << *max_error_it << std::endl << std::endl;
 }
@@ -393,12 +393,12 @@ void MultiValueBootstrapping(BigInteger QBFVInit, BigInteger PInput, BigInteger
     Ciphertext<DCRTPoly> ctxtAfterFBT1, ctxtAfterFBT2;
 
     auto exact(x);
-    std::transform(x.begin(), x.end(), exact.begin(), [&](const int64_t& elem) {
+    std::transform(x.begin(), x.end(), exact.begin(), [&](int64_t elem) {
         return (func1(elem) > POutput.ConvertToDouble() / 2.) ? func1(elem) - POutput.ConvertToInt() : func1(elem);
     });
 
     auto exact2(x);
-    std::transform(x.begin(), x.end(), exact2.begin(), [&](const int64_t& elem) {
+    std::transform(x.begin(), x.end(), exact2.begin(), [&](int64_t elem) {
         return (func2(elem) > POutput.ConvertToDouble() / 2.) ? func2(elem) - POutput.ConvertToInt() : func2(elem);
     });
 
@@ -459,7 +459,7 @@ void MultiValueBootstrapping(BigInteger QBFVInit, BigInteger PInput, BigInteger
 
     std::transform(exact.begin(), exact.end(), computed.begin(), exact.begin(), std::minus<int64_t>());
     std::transform(exact.begin(), exact.end(), exact.begin(),
-                   [&](const int64_t& elem) { return (std::abs(elem)) % (POutput.ConvertToInt()); });
+                   [&](int64_t elem) { return (std::abs(elem)) % (POutput.ConvertToInt()); });
     auto max_error_it = std::max_element(exact.begin(), exact.end());
     std::cerr << "Max absolute error obtained in the first LUT: " << *max_error_it << std::endl << std::endl;
 
@@ -473,7 +473,7 @@ void MultiValueBootstrapping(BigInteger QBFVInit, BigInteger PInput, BigInteger
 
     std::transform(exact2.begin(), exact2.end(), computed.begin(), exact2.begin(), std::minus<int64_t>());
     std::transform(exact2.begin(), exact2.end(), exact2.begin(),
-                   [&](const int64_t& elem) { return (std::abs(elem)) % (POutput.ConvertToInt()); });
+                   [&](int64_t elem) { return (std::abs(elem)) % (POutput.ConvertToInt()); });
     max_error_it = std::max_element(exact2.begin(), exact2.end());
     std::cerr << "Max absolute error obtained in the second LUT: " << *max_error_it << std::endl << std::endl;
 }
@@ -514,7 +514,7 @@ void MultiPrecisionSign(BigInteger QBFVInit, BigInteger PInput, BigInteger PDigi
 
     auto exact(x);
     std::transform(x.begin(), x.end(), exact.begin(),
-                   [&](const int64_t& elem) { return (elem >= PInput.ConvertToDouble() / 2.); });
+                   [&](int64_t elem) { return (elem >= PInput.ConvertToDouble() / 2.); });
 
     /* 4. The case of Boolean LUTs using the first order Trigonometric Hermite Interpolation
      * supports an optimized implementation.
@@ -691,7 +691,7 @@ void MultiPrecisionSign(BigInteger QBFVInit, BigInteger PInput, BigInteger PDigi
 
             std::transform(exact.begin(), exact.end(), computed.begin(), exact.begin(), std::minus<int64_t>());
             std::transform(exact.begin(), exact.end(), exact.begin(),
-                           [&](const int64_t& elem) { return (std::abs(elem)) % (pOrig.ConvertToInt()); });
+                           [&](int64_t elem) { return (std::abs(elem)) % (pOrig.ConvertToInt()); });
             auto max_error_it = std::max_element(exact.begin(), exact.end());
             std::cerr << "\nMax absolute error obtained: " << *max_error_it << std::endl << std::endl;
         }
diff --git a/src/pke/examples/scheme-switching.cpp b/src/pke/examples/scheme-switching.cpp
@@ -1489,14 +1489,14 @@ void PolyViaSchemeSwitching() {
     std::vector<int32_t> x1Rot(RotateInt(x1, 1));
     std::transform(x1Rot.begin(), x1Rot.end(), x1.begin(), x1Rot.begin(), std::plus<int>());
     std::vector<int32_t> x1Int(slots);
-    std::transform(x1Rot.begin(), x1Rot.end(), x1Int.begin(), [&](const int32_t& elem) {
+    std::transform(x1Rot.begin(), x1Rot.end(), x1Int.begin(), [&](int32_t elem) {
         return static_cast<int32_t>(static_cast<int32_t>(std::round(0.25 * elem * elem)) % pLWE1);
     });
 
     std::vector<int32_t> x2Rot(RotateInt(x2, 2));
     std::transform(x2Rot.begin(), x2Rot.end(), x2.begin(), x2Rot.begin(), std::plus<int>());
     std::vector<int32_t> x2Int(slots);
-    std::transform(x2Rot.begin(), x2Rot.end(), x2Int.begin(), [&](const int32_t& elem) {
+    std::transform(x2Rot.begin(), x2Rot.end(), x2Int.begin(), [&](int32_t elem) {
         return static_cast<int32_t>(static_cast<int32_t>(std::round(0.25 * elem * elem)) % pLWE2);
     });
 
diff --git a/src/pke/unittest/utckksrns/UnitTestFBT.cpp b/src/pke/unittest/utckksrns/UnitTestFBT.cpp

Original file line number	Diff line number	Diff line change
`@@ -187,7 +187,7 @@ static void BM_BigInt_DividedByEq(benchmark::State& state) {`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`template <typename I>`
`190`		`-static void exp_BigInt(const I& a, const uint32_t& b) {`
	`190`	`+static void exp_BigInt(const I& a, uint32_t b) {`
`191`	`191`	`__attribute__((unused)) I c1 = a.Exp(b);`
`192`	`192`	`}`
`193`	`193`
`@@ -199,7 +199,7 @@ static void BM_BigInt_Exp(benchmark::State& state) {`
`199`	`199`	`}`
`200`	`200`
`201`	`201`	`template <typename I>`
`202`		`-static void expeq_BigInt(I a, const uint32_t& b) {`
	`202`	`+static void expeq_BigInt(I a, uint32_t b) {`
`203`	`203`	`a.ExpEq(b);`
`204`	`204`	`}`
`205`	`205`
`@@ -239,7 +239,7 @@ static void BM_BigInt_MultiplyAndRoundEq(benchmark::State& state) {`
`239`	`239`	`}`
`240`	`240`
`241`	`241`	`template <typename I>`
`242`		`-static void lshift_BigInt(const I& a, const uint16_t& b) {`
	`242`	`+static void lshift_BigInt(const I& a, uint16_t b) {`
`243`	`243`	`__attribute__((unused)) I c1 = a.LShift(b);`
`244`	`244`	`}`
`245`	`245`
`@@ -251,7 +251,7 @@ static void BM_BigInt_LShift(benchmark::State& state) {`
`251`	`251`	`}`
`252`	`252`
`253`	`253`	`template <typename I>`
`254`		`-static void lshifteq_BigInt(I a, const uint16_t& b) {`
	`254`	`+static void lshifteq_BigInt(I a, uint16_t b) {`
`255`	`255`	`a.LShiftEq(b);`
`256`	`256`	`}`
`257`	`257`
`@@ -263,7 +263,7 @@ static void BM_BigInt_LShiftEq(benchmark::State& state) {`
`263`	`263`	`}`
`264`	`264`
`265`	`265`	`template <typename I>`
`266`		`-static void rshift_BigInt(const I& a, const uint16_t& b) {`
	`266`	`+static void rshift_BigInt(const I& a, uint16_t b) {`
`267`	`267`	`__attribute__((unused)) I c1 = a.RShift(b);`
`268`	`268`	`}`
`269`	`269`
`@@ -275,7 +275,7 @@ static void BM_BigInt_RShift(benchmark::State& state) {`
`275`	`275`	`}`
`276`	`276`
`277`	`277`	`template <typename I>`
`278`		`-static void rshifteq_BigInt(I a, const uint16_t& b) {`
	`278`	`+static void rshifteq_BigInt(I a, uint16_t b) {`
`279`	`279`	`a.RShiftEq(b);`
`280`	`280`	`}`
`281`	`281`
Original file line number	Diff line number	Diff line change
`@@ -195,7 +195,7 @@ class myVecP : public NTL::Vec<myT>,`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`// sets modulus and the NTL init function uint64_t argument`
`198`		`- inline void SetModulus(const uint64_t& value) {`
	`198`	`+ inline void SetModulus(uint64_t value) {`
`199`	`199`	`if (value == 0) {`
`200`	`200`	`OPENFHE_THROW("SetModulus(uint64_t) cannot be zero");`
`201`	`201`	`}`