fmt

math/src/ring/impl_u64/rescaling_rns.rs

@@ -1,5 +1,5 @@
 use crate::modulus::barrett::Barrett;
-use crate::modulus::{NONE, ONCE, BARRETT};
+use crate::modulus::{BARRETT, NONE, ONCE};
 use crate::poly::PolyRNS;
 use crate::ring::Ring;
 use crate::ring::RingRNS;
@@ -31,9 +31,8 @@ impl RingRNS<u64> {
         let level = self.level();
         let rescaling_constants: ScalarRNS<Barrett<u64>> = self.rescaling_constant();
         let r_last: &Ring<u64> = &self.0[level];
-        
-        if ROUND{
 
+        if ROUND {
             let q_level_half: u64 = r_last.modulus.q >> 1;
 
             let (buf_q_scaling, buf_qi_scaling) = buf.0.split_at_mut(1);
@@ -56,7 +55,11 @@ impl RingRNS<u64> {
                     );
                 }
             } else {
-                r_last.a_add_b_scalar_into_c::<ONCE>(a.at(self.level()), &q_level_half, &mut buf_q_scaling[0]);
+                r_last.a_add_b_scalar_into_c::<ONCE>(
+                    a.at(self.level()),
+                    &q_level_half,
+                    &mut buf_q_scaling[0],
+                );
                 for (i, r) in self.0[0..level].iter().enumerate() {
                     r_last.a_add_b_scalar_into_c::<NONE>(
                         &buf_q_scaling[0],
@@ -71,7 +74,7 @@ impl RingRNS<u64> {
                     );
                 }
             }
-        }else{
+        } else {
             if NTT {
                 let (buf_ntt_q_scaling, buf_ntt_qi_scaling) = buf.0.split_at_mut(1);
                 self.0[level].intt::<false>(a.at(level), &mut buf_ntt_q_scaling[0]);
@@ -115,8 +118,7 @@ impl RingRNS<u64> {
         let rescaling_constants: ScalarRNS<Barrett<u64>> = self.rescaling_constant();
         let r_last: &Ring<u64> = &self.0[level];
 
-        if ROUND{
-
+        if ROUND {
             let q_level_half: u64 = r_last.modulus.q >> 1;
             let (buf_q_scaling, buf_qi_scaling) = buf.0.split_at_mut(1);
 
@@ -148,8 +150,7 @@ impl RingRNS<u64> {
                     );
                 }
             }
-        }else{
-
+        } else {
             if NTT {
                 let (buf_ntt_q_scaling, buf_ntt_qi_scaling) = buf.0.split_at_mut(1);
                 r_last.intt::<false>(a.at(level), &mut buf_ntt_q_scaling[0]);
@@ -161,7 +162,7 @@ impl RingRNS<u64> {
                         a.at_mut(i),
                     );
                 }
-            }else{
+            } else {
                 let (a_i, a_level) = a.0.split_at_mut(level);
                 for (i, r) in self.0[0..level].iter().enumerate() {
                     r.b_sub_a_mul_c_scalar_barrett_into_a::<2, ONCE>(
@@ -172,7 +173,6 @@ impl RingRNS<u64> {
                 }
             }
         }
-        
     }
 
     /// Updates b to floor(a / prod_{level - nb_moduli}^{level} q[i])
@@ -207,14 +207,13 @@ impl RingRNS<u64> {
             c.level(),
             a.level() - nb_moduli
         );
-    
+
         if nb_moduli == 0 {
             if a != c {
                 c.copy(a);
             }
         } else {
-
-            if NTT{
+            if NTT {
                 self.intt::<false>(a, buf);
                 (0..nb_moduli).for_each(|i| {
                     self.at_level(self.level() - i)
@@ -224,24 +223,24 @@ impl RingRNS<u64> {
                         )
                 });
                 self.at_level(self.level() - nb_moduli).ntt::<false>(buf, c);
-            }else{
-                
+            } else {
                 println!("{} {:?}", self.level(), buf.level());
                 self.div_by_last_modulus::<ROUND, false>(a, buf, c);
 
-                (1..nb_moduli-1).for_each(|i| {
+                (1..nb_moduli - 1).for_each(|i| {
                     println!("{} {:?}", self.level() - i, buf.level());
                     self.at_level(self.level() - i)
                         .div_by_last_modulus_inplace::<ROUND, false>(buf, c);
                 });
-                
-                self.at_level(self.level()-nb_moduli+1).div_by_last_modulus_inplace::<ROUND, false>(buf, c);
+
+                self.at_level(self.level() - nb_moduli + 1)
+                    .div_by_last_modulus_inplace::<ROUND, false>(buf, c);
             }
         }
     }
 
     /// Updates a to floor(a / prod_{level - nb_moduli}^{level} q[i])
-    pub fn div_by_last_moduli_inplace<const ROUND:bool, const NTT: bool>(
+    pub fn div_by_last_moduli_inplace<const ROUND: bool, const NTT: bool>(
         &self,
         nb_moduli: usize,
         buf: &mut PolyRNS<u64>,
@@ -259,15 +258,18 @@ impl RingRNS<u64> {
             nb_moduli,
             a.level()
         );
-        if nb_moduli == 0{
-            return
+        if nb_moduli == 0 {
+            return;
         }
 
         if NTT {
             self.intt::<false>(a, buf);
             (0..nb_moduli).for_each(|i| {
                 self.at_level(self.level() - i)
-                    .div_by_last_modulus_inplace::<ROUND, false>(&mut PolyRNS::<u64>::default(), buf)
+                    .div_by_last_modulus_inplace::<ROUND, false>(
+                        &mut PolyRNS::<u64>::default(),
+                        buf,
+                    )
             });
             self.at_level(self.level() - nb_moduli).ntt::<false>(buf, a);
         } else {

math/src/ring/impl_u64/ring.rs

@@ -83,7 +83,12 @@ impl Ring<u64> {
     }
 
     #[inline(always)]
-    pub fn a_add_b_into_c<const REDUCE: REDUCEMOD>(&self, a: &Poly<u64>, b: &Poly<u64>, c: &mut Poly<u64>) {
+    pub fn a_add_b_into_c<const REDUCE: REDUCEMOD>(
+        &self,
+        a: &Poly<u64>,
+        b: &Poly<u64>,
+        c: &mut Poly<u64>,
+    ) {
         debug_assert!(a.n() == self.n(), "a.n()={} != n={}", a.n(), self.n());
         debug_assert!(b.n() == self.n(), "b.n()={} != n={}", b.n(), self.n());
         debug_assert!(c.n() == self.n(), "c.n()={} != n={}", c.n(), self.n());
@@ -98,7 +103,12 @@ impl Ring<u64> {
     }
 
     #[inline(always)]
-    pub fn a_add_b_scalar_into_c<const REDUCE: REDUCEMOD>(&self, a: &Poly<u64>, b: &u64, c: &mut Poly<u64>) {
+    pub fn a_add_b_scalar_into_c<const REDUCE: REDUCEMOD>(
+        &self,
+        a: &Poly<u64>,
+        b: &u64,
+        c: &mut Poly<u64>,
+    ) {
         debug_assert!(a.n() == self.n(), "a.n()={} != n={}", a.n(), self.n());
         debug_assert!(c.n() == self.n(), "c.n()={} != n={}", c.n(), self.n());
         self.modulus
@@ -106,13 +116,25 @@ impl Ring<u64> {
     }
 
     #[inline(always)]
-    pub fn a_add_scalar_b_mul_c_scalar_barrett_into_a<const REDUCE: REDUCEMOD>(&self, b: &u64, c: &Barrett<u64>, a: &mut Poly<u64>) {
+    pub fn a_add_scalar_b_mul_c_scalar_barrett_into_a<const REDUCE: REDUCEMOD>(
+        &self,
+        b: &u64,
+        c: &Barrett<u64>,
+        a: &mut Poly<u64>,
+    ) {
         debug_assert!(a.n() == self.n(), "b.n()={} != n={}", a.n(), self.n());
-        self.modulus.va_add_sb_mul_sc_into_va::<CHUNK, REDUCE>(b, c, &mut a.0);
+        self.modulus
+            .va_add_sb_mul_sc_into_va::<CHUNK, REDUCE>(b, c, &mut a.0);
     }
 
     #[inline(always)]
-    pub fn add_scalar_then_mul_scalar_barrett<const REDUCE: REDUCEMOD>(&self, a: &Poly<u64>, b: &u64, c: &Barrett<u64>, d: &mut Poly<u64>) {
+    pub fn add_scalar_then_mul_scalar_barrett<const REDUCE: REDUCEMOD>(
+        &self,
+        a: &Poly<u64>,
+        b: &u64,
+        c: &Barrett<u64>,
+        d: &mut Poly<u64>,
+    ) {
         debug_assert!(a.n() == self.n(), "a.n()={} != n={}", a.n(), self.n());
         debug_assert!(d.n() == self.n(), "c.n()={} != n={}", d.n(), self.n());
         self.modulus
@@ -120,7 +142,11 @@ impl Ring<u64> {
     }
 
     #[inline(always)]
-    pub fn a_sub_b_into_b<const BRANGE:u8, const REDUCE: REDUCEMOD>(&self, a: &Poly<u64>, b: &mut Poly<u64>) {
+    pub fn a_sub_b_into_b<const BRANGE: u8, const REDUCE: REDUCEMOD>(
+        &self,
+        a: &Poly<u64>,
+        b: &mut Poly<u64>,
+    ) {
         debug_assert!(a.n() == self.n(), "a.n()={} != n={}", a.n(), self.n());
         debug_assert!(b.n() == self.n(), "b.n()={} != n={}", b.n(), self.n());
         self.modulus
@@ -128,7 +154,11 @@ impl Ring<u64> {
     }
 
     #[inline(always)]
-    pub fn a_sub_b_into_a<const BRANGE:u8, const REDUCE: REDUCEMOD>(&self, b: &Poly<u64>, a: &mut Poly<u64>) {
+    pub fn a_sub_b_into_a<const BRANGE: u8, const REDUCE: REDUCEMOD>(
+        &self,
+        b: &Poly<u64>,
+        a: &mut Poly<u64>,
+    ) {
         debug_assert!(a.n() == self.n(), "a.n()={} != n={}", a.n(), self.n());
         debug_assert!(b.n() == self.n(), "b.n()={} != n={}", b.n(), self.n());
         self.modulus
@@ -136,7 +166,12 @@ impl Ring<u64> {
     }
 
     #[inline(always)]
-    pub fn a_sub_b_into_c<const BRANGE:u8, const REDUCE: REDUCEMOD>(&self, a: &Poly<u64>, b: &Poly<u64>, c: &mut Poly<u64>) {
+    pub fn a_sub_b_into_c<const BRANGE: u8, const REDUCE: REDUCEMOD>(
+        &self,
+        a: &Poly<u64>,
+        b: &Poly<u64>,
+        c: &mut Poly<u64>,
+    ) {
         debug_assert!(a.n() == self.n(), "a.n()={} != n={}", a.n(), self.n());
         debug_assert!(b.n() == self.n(), "b.n()={} != n={}", b.n(), self.n());
         debug_assert!(c.n() == self.n(), "c.n()={} != n={}", c.n(), self.n());
@@ -145,16 +180,22 @@ impl Ring<u64> {
     }
 
     #[inline(always)]
-    pub fn a_neg_into_b<const ARANGE:u8, const REDUCE: REDUCEMOD>(&self, a: &Poly<u64>, b: &mut Poly<u64>) {
+    pub fn a_neg_into_b<const ARANGE: u8, const REDUCE: REDUCEMOD>(
+        &self,
+        a: &Poly<u64>,
+        b: &mut Poly<u64>,
+    ) {
         debug_assert!(a.n() == self.n(), "a.n()={} != n={}", a.n(), self.n());
         debug_assert!(b.n() == self.n(), "b.n()={} != n={}", b.n(), self.n());
-        self.modulus.va_neg_into_vb::<CHUNK, ARANGE, REDUCE>(&a.0, &mut b.0);
+        self.modulus
+            .va_neg_into_vb::<CHUNK, ARANGE, REDUCE>(&a.0, &mut b.0);
     }
 
     #[inline(always)]
-    pub fn a_neg_into_a<const ARANGE:u8,const REDUCE: REDUCEMOD>(&self, a: &mut Poly<u64>) {
+    pub fn a_neg_into_a<const ARANGE: u8, const REDUCE: REDUCEMOD>(&self, a: &mut Poly<u64>) {
         debug_assert!(a.n() == self.n(), "a.n()={} != n={}", a.n(), self.n());
-        self.modulus.va_neg_into_va::<CHUNK, ARANGE, REDUCE>(&mut a.0);
+        self.modulus
+            .va_neg_into_va::<CHUNK, ARANGE, REDUCE>(&mut a.0);
     }
 
     #[inline(always)]
@@ -184,7 +225,12 @@ impl Ring<u64> {
     }
 
     #[inline(always)]
-    pub fn a_mul_b_scalar_into_c<const REDUCE: REDUCEMOD>(&self, a: &Poly<u64>, b: &u64, c: &mut Poly<u64>) {
+    pub fn a_mul_b_scalar_into_c<const REDUCE: REDUCEMOD>(
+        &self,
+        a: &Poly<u64>,
+        b: &u64,
+        c: &mut Poly<u64>,
+    ) {
         debug_assert!(a.n() == self.n(), "a.n()={} != n={}", a.n(), self.n());
         debug_assert!(c.n() == self.n(), "c.n()={} != n={}", c.n(), self.n());
         self.modulus.sa_barrett_mul_vb_into_vc::<CHUNK, REDUCE>(
@@ -258,14 +304,17 @@ impl Ring<u64> {
     }
 
     #[inline(always)]
-    pub fn a_sub_b_add_c_scalar_mul_d_scalar_barrett_into_e<const BRANGE: u8, const REDUCE: REDUCEMOD>(
+    pub fn a_sub_b_add_c_scalar_mul_d_scalar_barrett_into_e<
+        const BRANGE: u8,
+        const REDUCE: REDUCEMOD,
+    >(
         &self,
         a: &Poly<u64>,
         b: &Poly<u64>,
         c: &u64,
         d: &Barrett<u64>,
         e: &mut Poly<u64>,
-    ){
+    ) {
         debug_assert!(a.n() == self.n(), "a.n()={} != n={}", a.n(), self.n());
         debug_assert!(b.n() == self.n(), "b.n()={} != n={}", b.n(), self.n());
         debug_assert!(e.n() == self.n(), "e.n()={} != n={}", e.n(), self.n());
@@ -274,17 +323,19 @@ impl Ring<u64> {
     }
 
     #[inline(always)]
-    pub fn b_sub_a_add_c_scalar_mul_d_scalar_barrett_into_a<const BRANGE: u8, const REDUCE: REDUCEMOD>(
+    pub fn b_sub_a_add_c_scalar_mul_d_scalar_barrett_into_a<
+        const BRANGE: u8,
+        const REDUCE: REDUCEMOD,
+    >(
         &self,
         b: &Poly<u64>,
         c: &u64,
         d: &Barrett<u64>,
         a: &mut Poly<u64>,
-    ){
+    ) {
         debug_assert!(a.n() == self.n(), "a.n()={} != n={}", a.n(), self.n());
         debug_assert!(b.n() == self.n(), "b.n()={} != n={}", b.n(), self.n());
         self.modulus
             .vb_sub_va_add_sc_mul_sd_into_va::<CHUNK, BRANGE, REDUCE>(&b.0, c, d, &mut a.0);
     }
-    
 }

math/src/ring/impl_u64/ring_rns.rs

@@ -7,8 +7,6 @@ use crate::scalar::ScalarRNS;
 use num_bigint::BigInt;
 use std::sync::Arc;
 
-
-
 impl RingRNS<u64> {
     pub fn new(n: usize, moduli: Vec<u64>) -> Self {
         assert!(!moduli.is_empty(), "moduli cannot be empty");
@@ -198,14 +196,17 @@ impl RingRNS<u64> {
             c.level(),
             self.level()
         );
-        self.0
-            .iter()
-            .enumerate()
-            .for_each(|(i, ring)| ring.a_sub_b_into_c::<BRANGE, REDUCE>(&a.0[i], &b.0[i], &mut c.0[i]));
+        self.0.iter().enumerate().for_each(|(i, ring)| {
+            ring.a_sub_b_into_c::<BRANGE, REDUCE>(&a.0[i], &b.0[i], &mut c.0[i])
+        });
     }
 
     #[inline(always)]
-    pub fn a_sub_b_into_b<const BRANGE: u8, const REDUCE: REDUCEMOD>(&self, a: &PolyRNS<u64>, b: &mut PolyRNS<u64>) {
+    pub fn a_sub_b_into_b<const BRANGE: u8, const REDUCE: REDUCEMOD>(
+        &self,
+        a: &PolyRNS<u64>,
+        b: &mut PolyRNS<u64>,
+    ) {
         debug_assert!(
             a.level() >= self.level(),
             "a.level()={} < self.level()={}",
@@ -225,7 +226,11 @@ impl RingRNS<u64> {
     }
 
     #[inline(always)]
-    pub fn a_sub_b_into_a<const BRANGE: u8, const REDUCE: REDUCEMOD>(&self, b: &PolyRNS<u64>, a: &mut PolyRNS<u64>) {
+    pub fn a_sub_b_into_a<const BRANGE: u8, const REDUCE: REDUCEMOD>(
+        &self,
+        b: &PolyRNS<u64>,
+        a: &mut PolyRNS<u64>,
+    ) {
         debug_assert!(
             a.level() >= self.level(),
             "a.level()={} < self.level()={}",
@@ -245,7 +250,11 @@ impl RingRNS<u64> {
     }
 
     #[inline(always)]
-    pub fn a_neg_into_b<const ARANGE: u8, const REDUCE: REDUCEMOD>(&self, a: &PolyRNS<u64>, b: &mut PolyRNS<u64>) {
+    pub fn a_neg_into_b<const ARANGE: u8, const REDUCE: REDUCEMOD>(
+        &self,
+        a: &PolyRNS<u64>,
+        b: &mut PolyRNS<u64>,
+    ) {
         debug_assert!(
             a.level() >= self.level(),
             "a.level()={} < self.level()={}",
@@ -326,9 +335,10 @@ impl RingRNS<u64> {
             b.level(),
             self.level()
         );
-        self.0.iter().enumerate().for_each(|(i, ring)| {
-            ring.a_mul_b_montgomery_into_a::<REDUCE>(&a.0[i], &mut b.0[i])
-        });
+        self.0
+            .iter()
+            .enumerate()
+            .for_each(|(i, ring)| ring.a_mul_b_montgomery_into_a::<REDUCE>(&a.0[i], &mut b.0[i]));
     }
 
     #[inline(always)]
@@ -371,7 +381,17 @@ impl RingRNS<u64> {
     }
 
     #[inline(always)]
-    pub fn a_sub_b_add_scalar_mul_scalar_barrett_into_e<const BRANGE:u8, const REDUCE:REDUCEMOD>(&self, a: &PolyRNS<u64>, b: &PolyRNS<u64>, c: &u64, d: &Barrett<u64>, e: &mut PolyRNS<u64>){
+    pub fn a_sub_b_add_scalar_mul_scalar_barrett_into_e<
+        const BRANGE: u8,
+        const REDUCE: REDUCEMOD,
+    >(
+        &self,
+        a: &PolyRNS<u64>,
+        b: &PolyRNS<u64>,
+        c: &u64,
+        d: &Barrett<u64>,
+        e: &mut PolyRNS<u64>,
+    ) {
         debug_assert!(
             a.level() >= self.level(),
             "a.level()={} < self.level()={}",
@@ -390,14 +410,28 @@ impl RingRNS<u64> {
             e.level(),
             self.level()
         );
-        self.0
-            .iter()
-            .enumerate()
-            .for_each(|(i, ring)| ring.a_sub_b_add_c_scalar_mul_d_scalar_barrett_into_e::<BRANGE, REDUCE>(&a.0[i], &b.0[i], c, d, &mut e.0[i]));
+        self.0.iter().enumerate().for_each(|(i, ring)| {
+            ring.a_sub_b_add_c_scalar_mul_d_scalar_barrett_into_e::<BRANGE, REDUCE>(
+                &a.0[i],
+                &b.0[i],
+                c,
+                d,
+                &mut e.0[i],
+            )
+        });
     }
 
     #[inline(always)]
-    pub fn b_sub_a_add_c_scalar_mul_d_scalar_barrett_into_a<const BRANGE:u8, const REDUCE:REDUCEMOD>(&self, b: &PolyRNS<u64>, c: &u64, d: &Barrett<u64>, a: &mut PolyRNS<u64>){
+    pub fn b_sub_a_add_c_scalar_mul_d_scalar_barrett_into_a<
+        const BRANGE: u8,
+        const REDUCE: REDUCEMOD,
+    >(
+        &self,
+        b: &PolyRNS<u64>,
+        c: &u64,
+        d: &Barrett<u64>,
+        a: &mut PolyRNS<u64>,
+    ) {
         debug_assert!(
             a.level() >= self.level(),
             "a.level()={} < self.level()={}",
@@ -410,9 +444,13 @@ impl RingRNS<u64> {
             b.level(),
             self.level()
         );
-        self.0
-            .iter()
-            .enumerate()
-            .for_each(|(i, ring)| ring.b_sub_a_add_c_scalar_mul_d_scalar_barrett_into_a::<BRANGE, REDUCE>(&b.0[i], c, d, &mut a.0[i]));
+        self.0.iter().enumerate().for_each(|(i, ring)| {
+            ring.b_sub_a_add_c_scalar_mul_d_scalar_barrett_into_a::<BRANGE, REDUCE>(
+                &b.0[i],
+                c,
+                d,
+                &mut a.0[i],
+            )
+        });
     }
 }

math/src/ring/impl_u64/sampling.rs

@@ -2,7 +2,7 @@ use crate::modulus::WordOps;
 use crate::poly::{Poly, PolyRNS};
 use crate::ring::{Ring, RingRNS};
 use num::ToPrimitive;
-use rand_distr::{Normal, Distribution};
+use rand_distr::{Distribution, Normal};
 use sampling::source::Source;
 
 impl Ring<u64> {
@@ -13,21 +13,25 @@ impl Ring<u64> {
             .for_each(|a| *a = source.next_u64n(max, mask));
     }
 
-    pub fn fill_dist_f64<T: Distribution<f64>>(&self, source: &mut Source, dist: T, bound: f64, a: &mut Poly<u64>) {
+    pub fn fill_dist_f64<T: Distribution<f64>>(
+        &self,
+        source: &mut Source,
+        dist: T,
+        bound: f64,
+        a: &mut Poly<u64>,
+    ) {
         let max: u64 = self.modulus.q;
-        a.0.iter_mut()
-            .for_each(|a| {
+        a.0.iter_mut().for_each(|a| {
+            let mut dist_f64: f64 = dist.sample(source);
 
-                let mut dist_f64: f64 = dist.sample(source);
-                
-                while dist_f64.abs() > bound{
-                    dist_f64 = dist.sample(source)
-                }
+            while dist_f64.abs() > bound {
+                dist_f64 = dist.sample(source)
+            }
 
-                let dist_u64: u64 = (dist_f64+0.5).abs().to_u64().unwrap();
-                let sign: u64 = dist_f64.to_bits()>>63;
+            let dist_u64: u64 = (dist_f64 + 0.5).abs().to_u64().unwrap();
+            let sign: u64 = dist_f64.to_bits() >> 63;
 
-                *a = (dist_u64 * sign) | (max-dist_u64)*(sign^1)
+            *a = (dist_u64 * sign) | (max - dist_u64) * (sign ^ 1)
         });
     }
 }
@@ -40,19 +44,25 @@ impl RingRNS<u64> {
             .for_each(|(i, r)| r.fill_uniform(source, a.at_mut(i)));
     }
 
-    pub fn fill_dist_f64<T: Distribution<f64>>(&self, source: &mut Source, dist: T, bound: f64, a: &mut PolyRNS<u64>) {
-        (0..a.n()).for_each(|j|{
+    pub fn fill_dist_f64<T: Distribution<f64>>(
+        &self,
+        source: &mut Source,
+        dist: T,
+        bound: f64,
+        a: &mut PolyRNS<u64>,
+    ) {
+        (0..a.n()).for_each(|j| {
             let mut dist_f64: f64 = dist.sample(source);
-                
-            while dist_f64.abs() > bound{
+
+            while dist_f64.abs() > bound {
                 dist_f64 = dist.sample(source)
             }
 
-            let dist_u64: u64 = (dist_f64+0.5).abs().to_u64().unwrap();
-            let sign: u64 = dist_f64.to_bits()>>63;
+            let dist_u64: u64 = (dist_f64 + 0.5).abs().to_u64().unwrap();
+            let sign: u64 = dist_f64.to_bits() >> 63;
 
-            self.0.iter().enumerate().for_each(|(i, r)|{
-                a.at_mut(i).0[j] = (dist_u64 * sign) | (r.modulus.q-dist_u64)*(sign^1);
+            self.0.iter().enumerate().for_each(|(i, r)| {
+                a.at_mut(i).0[j] = (dist_u64 * sign) | (r.modulus.q - dist_u64) * (sign ^ 1);
             })
         })
     }