made code cleaner

Author: IanQS

README.md

@@ -50,3 +50,7 @@ a [numpy-like](https://numpy.org/) interface for use in encrypted machine learni
 - vstack
   - re: expensive transpose, we do a hstack on the transpose to get the resulting transpose without actually doing the
     entire thing
+
+# Trivia
+
+This library is pronounced Tensor as the "p" is silent.

linear_regression_ames.cpp

@@ -71,8 +71,8 @@ int main() {
     // If numFolds ==1, we shuffle the single dataset
     // If numFolds == 0, we keep the order
     int numFolds = 0;
-    float _alpha = 0.075;
-    float _l2_regularization_factor = 0.25;
+    float _alpha = 0.5;
+    float _l2_regularization_factor = -1;
 
     uint8_t multDepth = 8;
     uint8_t scalingFactorBits = 45;

src/p_tensor.cpp

@@ -73,7 +73,6 @@ cipherTensor pTensor::binaryOpAbstraction(const char *flag,
 
     // Now, we know that it is broadcast-able. Therefore, they either have the same shape or one is shape 1 in rows
     cipherVector op_res;
-    int ringDim = (*m_cc)->GetRingDimension();
     for (unsigned int i = 0; i < std::max(m_rows, other.m_rows); i++) {
         unsigned int lhsInd;
         unsigned int rhsInd;
@@ -95,11 +94,10 @@ cipherTensor pTensor::binaryOpAbstraction(const char *flag,
             if (other.isScalar() && !(other.m_isRepeated)) {
 
                 // Get how much to sum over and rotate.
-                int rot = int(-ringDim / 4) + 1;
                 // We've now summed it up and it should be projected into the back
-                otherVec = (*m_cc)->EvalSum(other.m_ciphertexts[0], -rot);
+                otherVec = (*m_cc)->EvalSum(other.m_ciphertexts[0], -getRepeatBatchSize());
                 // The last rot entries are now populated with the value. We then rotate them back and we are done.
-                otherVec = (*m_cc)->EvalAtIndex(otherVec, rot);
+                otherVec = (*m_cc)->EvalAtIndex(otherVec, getRepeatBatchSize());
 
             } else {
                 otherVec = other.m_ciphertexts[rhsInd];
@@ -268,7 +266,7 @@ pTensor pTensor::dot(pTensor &other, bool asRowVector) {
         auto innerProd = (*m_cc)->EvalInnerProduct(
             m_ciphertexts[i],
             rhs.m_ciphertexts[HARDCODED_INDEX_FOR_OTHER_VECTOR],
-            ((*m_cc)->GetRingDimension() / 4));
+            getBatchSize());
 
         innerProd = (*m_cc)->EvalMult(innerProd, mask);
 
@@ -350,7 +348,7 @@ pTensor pTensor::sum(int axis) {
         // Sum across the rows
         cipherTensor accumulator;
         for (const auto &item : m_ciphertexts) {
-            auto resp = (*m_cc)->EvalSum(item, (*m_cc)->GetRingDimension() / 4);
+            auto resp = (*m_cc)->EvalSum(item, getBatchSize());
             accumulator.emplace_back(resp);
         }
 
@@ -562,16 +560,14 @@ pTensor pTensor::applyGradient(pTensor matrixOfWeights, pTensor vectorGradients)
 
     lbcrypto::Plaintext pt;
     int index = 0;
-    int ringDim = (*m_cc)->GetRingDimension();
-    int rot = int(-ringDim / 4) + 1;
 
     for (auto &row: maskedGradients.m_ciphertexts) {
         auto maskedVal = row;
         for (int i = 0; i < (index + 1); ++i) {
             maskedVal = (*m_cc)->EvalAtIndex(maskedVal, 1);
         }
-        maskedVal = (*m_cc)->EvalSum(maskedVal, -rot);
-        maskedVal = (*m_cc)->EvalAtIndex(maskedVal, rot);
+        maskedVal = (*m_cc)->EvalSum(maskedVal, -getRepeatBatchSize());
+        maskedVal = (*m_cc)->EvalAtIndex(maskedVal, getRepeatBatchSize());
         tensorCipherContainer.emplace_back(maskedVal);
         index += 1;
     }

src/p_tensor.h

@@ -512,6 +512,28 @@ class pTensor {
       return newTensor;
   }
 
+  /**
+   * Get the batch size for repetition of elements. The value of interest must be in the -1-th index slot (they wrap around). We
+   *    effectively sum which is a cumulative sum. Now, only the last batchSize values are the values of interest so we then
+   *    rotate the entire cipher around
+   *
+   * For the summation, we use the negative of this value
+   * For the rotation, we use the actual value
+   * @return
+   */
+  static int getRepeatBatchSize() {
+      int ringDim = (*m_cc)->GetRingDimension();
+      return int(-ringDim / 4) + 1;
+  };
+
+  /**
+   * Used for non-repeat sums and or inner products
+   * @return
+   */
+  static int getBatchSize() {
+      return int((*m_cc)->GetRingDimension() / 4);
+  }
+
  private:
 
   /**