use decomposer_iter

src/decomposer.rs

@@ -231,9 +231,8 @@ impl Iterator for DecomposerIter {
             // 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 @@ fn round_value(value: T, ignore_bits: usize) -> T {
 #[cfg(test)]
 mod tests {
 
+    use itertools::Itertools;
     use rand::{thread_rng, Rng};
 
     use crate::{
@@ -285,6 +285,8 @@ mod tests {
             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,

src/rgsw.rs

@@ -518,11 +518,18 @@ pub(crate) fn decompose_r>(
     let d = decomposer.decomposition_count();
 
     for ri in 0..ring_size {
-        let el_decomposed = decomposer.decompose_to_vec(&r[ri]);
-
-        for j in 0..d {
-            decomp_r[j].as_mut()[ri] = el_decomposed[j];
-        }
+        // 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];
+        // }
     }
 }
 
@@ -571,10 +578,18 @@ pub(crate) fn galois_auto<
         .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