Fixed gadget product & added noise estimations

base2k/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+rug = {workspace = true}
 criterion = {workspace = true}
 itertools = {workspace = true}
 rand = {workspace = true}

base2k/src/encoding.rs

@@ -1,6 +1,7 @@
 use crate::ffi::znx::znx_zero_i64_ref;
 use crate::{Infos, VecZnx, VecZnxApi};
 use itertools::izip;
+use rug::{Assign, Float};
 use std::cmp::min;
 
 pub trait Encoding {
@@ -23,6 +24,13 @@ pub trait Encoding {
     /// * `data`: data to decode from the receiver.
     fn decode_vec_i64(&self, log_base2k: usize, log_k: usize, data: &mut [i64]);
 
+    /// decode a vector of Float from the receiver.
+    ///
+    /// # Arguments
+    /// * `log_base2k`: base two logarithm decomposition of the receiver.
+    /// * `data`: data to decode from the receiver.
+    fn decode_vec_float(&self, log_base2k: usize, data: &mut [Float]);
+
     /// encodes a single i64 on the receiver at the given index.
     ///
     /// # Arguments
@@ -123,6 +131,36 @@ impl Encoding for VecZnx {
         })
     }
 
+    fn decode_vec_float(&self, log_base2k: usize, data: &mut [Float]) {
+        let cols: usize = self.cols();
+        assert!(
+            data.len() >= self.n(),
+            "invalid data: data.len()={} < self.n()={}",
+            data.len(),
+            self.n()
+        );
+
+        let prec: u32 = (log_base2k * cols) as u32;
+
+        // 2^{log_base2k}
+        let base = Float::with_val(prec, (1 << log_base2k) as f64);
+
+        // y[i] = sum x[j][i] * 2^{-log_base2k*j}
+        (0..cols).for_each(|i| {
+            if i == 0 {
+                izip!(self.at(cols - i - 1).iter(), data.iter_mut()).for_each(|(x, y)| {
+                    y.assign(*x);
+                    *y /= &base;
+                });
+            } else {
+                izip!(self.at(cols - i - 1).iter(), data.iter_mut()).for_each(|(x, y)| {
+                    *y += Float::with_val(prec, *x);
+                    *y /= &base;
+                });
+            }
+        });
+    }
+
     fn encode_coeff_i64(
         &mut self,
         log_base2k: usize,

base2k/src/lib.rs

@@ -12,6 +12,7 @@ pub mod free;
 pub mod infos;
 pub mod module;
 pub mod sampling;
+pub mod stats;
 pub mod svp;
 pub mod vec_znx;
 pub mod vec_znx_big;
@@ -23,6 +24,8 @@ pub use free::*;
 pub use infos::*;
 pub use module::*;
 pub use sampling::*;
+#[allow(unused_imports)]
+pub use stats::*;
 pub use svp::*;
 pub use vec_znx::*;
 pub use vec_znx_big::*;

base2k/src/stats.rs

@@ -0,0 +1,28 @@
+use crate::{Infos, VecZnx, Encoding};
+use rug::float::Round;
+use rug::ops::{AddAssignRound, SubAssignRound, DivAssignRound};
+use rug::Float;
+
+impl VecZnx {
+    pub fn std(&self, log_base2k: usize) -> f64 {
+        let prec: u32 = (self.cols() * log_base2k) as u32;
+        let mut data: Vec<Float> = (0..self.n()).map(|_| Float::with_val(prec, 0)).collect();
+        self.decode_vec_float(log_base2k, &mut data);
+        // std = sqrt(sum((xi - avg)^2) / n)
+        let mut avg: Float = Float::with_val(prec, 0);
+        data.iter().for_each(|x| {
+            avg.add_assign_round(x, Round::Nearest);
+        });
+        avg.div_assign_round(Float::with_val(prec, data.len()), Round::Nearest);
+        data.iter_mut().for_each(|x| {
+            x.sub_assign_round(&avg, Round::Nearest);
+        });
+        let mut std: Float = Float::with_val(prec, 0);
+        data.iter().for_each(|x| {
+            std += x*x
+        });
+        std.div_assign_round(Float::with_val(prec, data.len()), Round::Nearest);
+        std = std.sqrt();
+        std.to_f64()
+    }
+}

base2k/src/vec_znx.rs

@@ -42,6 +42,9 @@ pub trait VecZnxApi {
 
     /// Zeroes the backing array.
     fn zero(&mut self);
+
+    /// Normalization: propagates carry and ensures each coefficients
+    /// falls into the range [-2^{K-1}, 2^{K-1}].
     fn normalize(&mut self, log_base2k: usize, carry: &mut [u8]);
 
     /// Right shifts the coefficients by k bits.

base2k/src/vmp.rs

@@ -454,18 +454,18 @@ impl VmpPMatOps for Module {
 
     fn vmp_apply_dft_tmp_bytes(
         &self,
-        c_cols: usize,
+        res_cols: usize,
         a_cols: usize,
-        rows: usize,
-        cols: usize,
+        gct_rows: usize,
+        gct_cols: usize,
     ) -> usize {
         unsafe {
             vmp::vmp_apply_dft_tmp_bytes(
                 self.0,
-                c_cols as u64,
+                res_cols as u64,
                 a_cols as u64,
-                rows as u64,
-                cols as u64,
+                gct_rows as u64,
+                gct_cols as u64,
             ) as usize
         }
     }
@@ -495,18 +495,18 @@ impl VmpPMatOps for Module {
 
     fn vmp_apply_dft_to_dft_tmp_bytes(
         &self,
-        c_cols: usize,
+        res_cols: usize,
         a_cols: usize,
-        rows: usize,
-        cols: usize,
+        gct_rows: usize,
+        gct_cols: usize,
     ) -> usize {
         unsafe {
             vmp::vmp_apply_dft_to_dft_tmp_bytes(
                 self.0,
-                c_cols as u64,
+                res_cols as u64,
                 a_cols as u64,
-                rows as u64,
-                cols as u64,
+                gct_rows as u64,
+                gct_cols as u64,
             ) as usize
         }
     }