Add schemes (#71)

* Move br + cbt to schemes/tfhe

* refactor blind rotation

* refactor circuit bootstrapping

* renamed exec -> prepared

backend/src/hal/tests/vec_znx/encoding.rs

@@ -0,0 +1,52 @@
+use sampling::source::Source;
+
+use crate::hal::{
+    api::{ZnxInfos, ZnxViewMut},
+    layouts::VecZnx,
+};
+
+pub fn test_vec_znx_encode_vec_i64_lo_norm() {
+    let n: usize = 32;
+    let basek: usize = 17;
+    let size: usize = 5;
+    let k: usize = size * basek - 5;
+    let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, 2, size);
+    let mut source: Source = Source::new([0u8; 32]);
+    let raw: &mut [i64] = a.raw_mut();
+    raw.iter_mut().enumerate().for_each(|(i, x)| *x = i as i64);
+    (0..a.cols()).for_each(|col_i| {
+        let mut have: Vec<i64> = vec![i64::default(); n];
+        have.iter_mut()
+            .for_each(|x| *x = (source.next_i64() << 56) >> 56);
+        a.encode_vec_i64(basek, col_i, k, &have, 10);
+        let mut want: Vec<i64> = vec![i64::default(); n];
+        a.decode_vec_i64(basek, col_i, k, &mut want);
+        assert_eq!(have, want, "{:?} != {:?}", &have, &want);
+    });
+}
+
+pub fn test_vec_znx_encode_vec_i64_hi_norm() {
+    let n: usize = 32;
+    let basek: usize = 17;
+    let size: usize = 5;
+    for k in [1, basek / 2, size * basek - 5] {
+        let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, 2, size);
+        let mut source = Source::new([0u8; 32]);
+        let raw: &mut [i64] = a.raw_mut();
+        raw.iter_mut().enumerate().for_each(|(i, x)| *x = i as i64);
+        (0..a.cols()).for_each(|col_i| {
+            let mut have: Vec<i64> = vec![i64::default(); n];
+            have.iter_mut().for_each(|x| {
+                if k < 64 {
+                    *x = source.next_u64n(1 << k, (1 << k) - 1) as i64;
+                } else {
+                    *x = source.next_i64();
+                }
+            });
+            a.encode_vec_i64(basek, col_i, k, &have, 63);
+            let mut want: Vec<i64> = vec![i64::default(); n];
+            a.decode_vec_i64(basek, col_i, k, &mut want);
+            assert_eq!(have, want, "{:?} != {:?}", &have, &want);
+        })
+    }
+}

backend/src/hal/tests/vec_znx/generics.rs

@@ -1,14 +1,13 @@
-use itertools::izip;
 use sampling::source::Source;
 
 use crate::hal::{
-    api::{VecZnxAddNormal, VecZnxDecodeVeci64, VecZnxEncodeVeci64, VecZnxFillUniform, VecZnxStd, ZnxInfos, ZnxView, ZnxViewMut},
+    api::{VecZnxAddNormal, VecZnxFillUniform, ZnxView},
     layouts::{Backend, Module, VecZnx},
 };
 
 pub fn test_vec_znx_fill_uniform<B: Backend>(module: &Module<B>)
 where
-    Module<B>: VecZnxFillUniform + VecZnxStd,
+    Module<B>: VecZnxFillUniform,
 {
     let n: usize = module.n();
     let basek: usize = 17;
@@ -26,7 +25,7 @@ where
                     assert_eq!(a.at(col_j, limb_i), zero);
                 })
             } else {
-                let std: f64 = module.vec_znx_std(basek, &a, col_i);
+                let std: f64 = a.std(basek, col_i);
                 assert!(
                     (std - one_12_sqrt).abs() < 0.01,
                     "std={} ~!= {}",
@@ -40,7 +39,7 @@ where
 
 pub fn test_vec_znx_add_normal<B: Backend>(module: &Module<B>)
 where
-    Module<B>: VecZnxAddNormal + VecZnxStd,
+    Module<B>: VecZnxAddNormal,
 {
     let n: usize = module.n();
     let basek: usize = 17;
@@ -61,61 +60,9 @@ where
                     assert_eq!(a.at(col_j, limb_i), zero);
                 })
             } else {
-                let std: f64 = module.vec_znx_std(basek, &a, col_i) * k_f64;
+                let std: f64 = a.std(basek, col_i) * k_f64;
                 assert!((std - sigma).abs() < 0.1, "std={} ~!= {}", std, sigma);
             }
         })
     });
 }
-
-pub fn test_vec_znx_encode_vec_i64_lo_norm<B: Backend>(module: &Module<B>)
-where
-    Module<B>: VecZnxEncodeVeci64 + VecZnxDecodeVeci64,
-{
-    let n: usize = module.n();
-    let basek: usize = 17;
-    let size: usize = 5;
-    let k: usize = size * basek - 5;
-    let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, 2, size);
-    let mut source: Source = Source::new([0u8; 32]);
-    let raw: &mut [i64] = a.raw_mut();
-    raw.iter_mut().enumerate().for_each(|(i, x)| *x = i as i64);
-    (0..a.cols()).for_each(|col_i| {
-        let mut have: Vec<i64> = vec![i64::default(); n];
-        have.iter_mut()
-            .for_each(|x| *x = (source.next_i64() << 56) >> 56);
-        module.encode_vec_i64(basek, &mut a, col_i, k, &have, 10);
-        let mut want: Vec<i64> = vec![i64::default(); n];
-        module.decode_vec_i64(basek, &a, col_i, k, &mut want);
-        izip!(want, have).for_each(|(a, b)| assert_eq!(a, b, "{} != {}", a, b));
-    });
-}
-
-pub fn test_vec_znx_encode_vec_i64_hi_norm<B: Backend>(module: &Module<B>)
-where
-    Module<B>: VecZnxEncodeVeci64 + VecZnxDecodeVeci64,
-{
-    let n: usize = module.n();
-    let basek: usize = 17;
-    let size: usize = 5;
-    for k in [1, basek / 2, size * basek - 5] {
-        let mut a: VecZnx<Vec<u8>> = VecZnx::alloc(n, 2, size);
-        let mut source = Source::new([0u8; 32]);
-        let raw: &mut [i64] = a.raw_mut();
-        raw.iter_mut().enumerate().for_each(|(i, x)| *x = i as i64);
-        (0..a.cols()).for_each(|col_i| {
-            let mut have: Vec<i64> = vec![i64::default(); n];
-            have.iter_mut().for_each(|x| {
-                if k < 64 {
-                    *x = source.next_u64n(1 << k, (1 << k) - 1) as i64;
-                } else {
-                    *x = source.next_i64();
-                }
-            });
-            module.encode_vec_i64(basek, &mut a, col_i, k, &have, 63);
-            let mut want: Vec<i64> = vec![i64::default(); n];
-            module.decode_vec_i64(basek, &a, col_i, k, &mut want);
-            izip!(want, have).for_each(|(a, b)| assert_eq!(a, b, "{} != {}", a, b));
-        })
-    }
-}

backend/src/hal/tests/vec_znx/mod.rs

@@ -1,2 +1,5 @@
 mod generics;
 pub use generics::*;
+
+#[cfg(test)]
+mod encoding;