M src/decomposer.rs → src/decomposer.rs

@@ -231,9 +231,8 @@ //     k_i > self.bby2 || (k_i == self.bby2 && ((self.value &
             // T::one()) == T::one())), );
             // self.value = self.value + carry;
 
-            // Some(
-            //     (self.q & ((carry << self.logq) - (T::one() & carry))) + k_i
-            // - (carry << self.logb), )
+            // Some((self.q & ((carry << 55) - (T::one() & carry))) + k_i -
+            // (carry << self.logb))
 
             // Some(k_i)
         } else {
@@ -254,6 +253,7 @@
 #[cfg(test)]
 mod tests {
 
+    use itertools::Itertools;
     use rand::{thread_rng, Rng};
 
     use crate::{
@@ -285,6 +285,8 @@ let modq_op = ModularOpsU64::new(q);
             for _ in 0..100000 {
                 let value = rng.gen_range(0..q);
                 let limbs = decomposer.decompose_to_vec(&value);
+                let limbs_from_iter = decomposer.decompose_iter(&value).collect_vec();
+                assert_eq!(limbs, limbs_from_iter);
                 let value_back = round_value(
                     decomposer.recompose(&limbs, &modq_op),
                     decomposer.ignore_bits,

M src/rgsw.rs → src/rgsw.rs

@@ -518,11 +518,18 @@ let ring_size = r.len();
     let d = decomposer.decomposition_count();
 
     for ri in 0..ring_size {
-        let el_decomposed = decomposer.decompose_to_vec(&r[ri]);
+        // let el_decomposed = decomposer.decompose_to_vec(&r[ri]);
+
+        decomposer
+            .decompose_iter(&r[ri])
+            .enumerate()
+            .for_each(|(index, el)| {
+                decomp_r[index].as_mut()[ri] = el;
+            });
 
-        for j in 0..d {
-            decomp_r[j].as_mut()[ri] = el_decomposed[j];
-        }
+        // for j in 0..d {
+        //     decomp_r[j].as_mut()[ri] = el_decomposed[j];
+        // }
     }
 }
 
@@ -571,10 +578,18 @@ )
         .for_each(|(el_in, to_index, sign)| {
             let el_out = if !*sign { mod_op.neg(el_in) } else { *el_in };
 
-            let el_out_decomposed = decomposer.decompose_to_vec(&el_out);
-            for j in 0..d {
-                scratch_matrix_d_ring[j].as_mut()[*to_index] = el_out_decomposed[j];
-            }
+            // let el_out_decomposed = decomposer.decompose_to_vec(&el_out);
+
+            decomposer
+                .decompose_iter(&el_out)
+                .enumerate()
+                .for_each(|(index, el)| {
+                    scratch_matrix_d_ring[index].as_mut()[*to_index] = el;
+                });
+
+            // for j in 0..d {
+            //     scratch_matrix_d_ring[j].as_mut()[*to_index] =
+            // el_out_decomposed[j]; }
         });
 
         // transform decomposed a(X^k) to evaluation domain