updated handling of modulus

base2k/examples/rlwe_encrypt.rs

@@ -4,9 +4,9 @@ use sampling::source::Source;
 
 fn main() {
     let n: usize = 16;
-    let log_base2k: usize = 40;
-    let prec: usize = 54;
-    let log_scale: usize = 18;
+    let log_base2k: usize = 18;
+    let limbs: usize = 3;
+    let log_scale: usize = (limbs - 1) * log_base2k - 5;
     let module: Module = Module::new::<FFT64>(n);
 
     let mut carry: Vec<u8> = vec![0; module.vec_znx_big_normalize_tmp_bytes()];
@@ -14,7 +14,7 @@ fn main() {
     let seed: [u8; 32] = [0; 32];
     let mut source: Source = Source::new(seed);
 
-    let mut res: VecZnx = VecZnx::new(n, log_base2k, prec);
+    let mut res: VecZnx = VecZnx::new(n, log_base2k, limbs);
 
     // s <- Z_{-1, 0, 1}[X]/(X^{N}+1)
     let mut s: Scalar = Scalar::new(n);
@@ -27,8 +27,8 @@ fn main() {
     module.svp_prepare(&mut s_ppol, &s);
 
     // a <- Z_{2^prec}[X]/(X^{N}+1)
-    let mut a: VecZnx = VecZnx::new(n, log_base2k, prec);
-    a.fill_uniform(&mut source);
+    let mut a: VecZnx = VecZnx::new(n, log_base2k, limbs);
+    a.fill_uniform(&mut source, log_base2k * limbs);
 
     // Scratch space for DFT values
     let mut buf_dft: VecZnxDft = module.new_vec_znx_dft(a.limbs());
@@ -42,22 +42,23 @@ fn main() {
     // buf_big <- IDFT(buf_dft) (not normalized)
     module.vec_znx_idft_tmp_a(&mut buf_big, &mut buf_dft, a.limbs());
 
-    let mut m: VecZnx = VecZnx::new(n, log_base2k, prec - log_scale);
+    let mut m: VecZnx = VecZnx::new(n, log_base2k, 2);
+
     let mut want: Vec<i64> = vec![0; n];
     want.iter_mut()
         .for_each(|x| *x = source.next_u64n(16, 15) as i64);
 
     // m
-    m.from_i64(&want, 4);
+    m.from_i64(&want, 4, log_scale);
     m.normalize(&mut carry);
 
     // buf_big <- m - buf_big
     module.vec_znx_big_sub_small_a_inplace(&mut buf_big, &m);
 
     // b <- normalize(buf_big) + e
-    let mut b: VecZnx = VecZnx::new(n, log_base2k, prec);
+    let mut b: VecZnx = VecZnx::new(n, log_base2k, limbs);
     module.vec_znx_big_normalize(&mut b, &buf_big, &mut carry);
-    b.add_normal(&mut source, 3.2, 19.0);
+    b.add_normal(&mut source, 3.2, 19.0, log_base2k * limbs);
 
     //Decrypt
 
@@ -73,9 +74,9 @@ fn main() {
 
     // have = m * 2^{log_scale} + e
     let mut have: Vec<i64> = vec![i64::default(); n];
-    res.to_i64(&mut have);
+    res.to_i64(&mut have, res.limbs() * log_base2k);
 
-    let scale: f64 = (1 << log_scale) as f64;
+    let scale: f64 = (1 << (res.limbs() * log_base2k - log_scale)) as f64;
     izip!(want.iter(), have.iter())
         .enumerate()
         .for_each(|(i, (a, b))| {

base2k/examples/vector_matrix_product.rs

@@ -1,4 +1,5 @@
 use base2k::{Matrix3D, Module, VecZnx, VecZnxBig, VecZnxDft, VmpPMat, FFT64};
+use std::cmp::min;
 
 fn main() {
     let log_n = 5;
@@ -6,10 +7,10 @@ fn main() {
 
     let module: Module = Module::new::<FFT64>(n);
     let log_base2k: usize = 15;
-    let log_q: usize = 60;
-    let limbs: usize = (log_q + log_base2k - 1) / log_base2k;
+    let limbs: usize = 5;
+    let log_k: usize = log_base2k * limbs - 5;
 
-    let rows: usize = limbs + 1;
+    let rows: usize = limbs;
     let cols: usize = limbs + 1;
 
     // Maximum size of the byte scratch needed
@@ -21,23 +22,18 @@ fn main() {
     let mut a_values: Vec<i64> = vec![i64::default(); n];
     a_values[1] = (1 << log_base2k) + 1;
 
-    let mut a: VecZnx = module.new_vec_znx(log_base2k, log_q);
-    a.from_i64(&a_values, 32);
+    let mut a: VecZnx = module.new_vec_znx(log_base2k, limbs);
+    a.from_i64(&a_values, 32, log_k);
     a.normalize(&mut buf);
 
     (0..a.limbs()).for_each(|i| println!("{}: {:?}", i, a.at(i)));
 
     let mut b_mat: Matrix3D<i64> = Matrix3D::new(rows, cols, n);
 
-    (0..rows).for_each(|i| {
-        (0..cols).for_each(|j| {
-            b_mat.at_mut(i, j)[0] = (i * cols + j) as i64;
-            b_mat.at_mut(i, j)[0] = (i * cols + j) as i64;
-        })
+    (0..min(rows, cols)).for_each(|i| {
+        b_mat.at_mut(i, i)[1] = 1 as i64;
     });
 
-    //b_mat.data.iter_mut().enumerate().for_each(|(i, xi)| *xi = i as i64);
-
     println!();
     (0..rows).for_each(|i| {
         (0..cols).for_each(|j| println!("{} {}: {:?}", i, j, b_mat.at(i, j)));
@@ -47,24 +43,26 @@ fn main() {
     let mut vmp_pmat: VmpPMat = module.new_vmp_pmat(rows, cols);
     module.vmp_prepare_contiguous(&mut vmp_pmat, &b_mat.data, &mut buf);
 
+    /*
     (0..cols).for_each(|i| {
         (0..rows).for_each(|j| println!("{} {}: {:?}", i, j, vmp_pmat.at(i, j)));
         println!();
     });
+    */
 
-    println!("{:?}", vmp_pmat.as_f64());
+    //println!("{:?}", vmp_pmat.as_f64());
 
-    let mut c_dft: VecZnxDft = module.new_vec_znx_dft(limbs);
+    let mut c_dft: VecZnxDft = module.new_vec_znx_dft(cols);
     module.vmp_apply_dft(&mut c_dft, &a, &vmp_pmat, &mut buf);
 
     let mut c_big: VecZnxBig = c_dft.as_vec_znx_big();
-    module.vec_znx_idft_tmp_a(&mut c_big, &mut c_dft, limbs);
+    module.vec_znx_idft_tmp_a(&mut c_big, &mut c_dft, cols);
 
-    let mut res: VecZnx = module.new_vec_znx(log_base2k, log_q);
+    let mut res: VecZnx = module.new_vec_znx(log_base2k, cols);
     module.vec_znx_big_normalize(&mut res, &c_big, &mut buf);
 
     let mut values_res: Vec<i64> = vec![i64::default(); n];
-    res.to_i64(&mut values_res);
+    res.to_i64(&mut values_res, log_k);
 
     (0..res.limbs()).for_each(|i| println!("{}: {:?}", i, res.at(i)));
 
@@ -72,5 +70,5 @@ fn main() {
     c_dft.delete();
     vmp_pmat.delete();
 
-    println!("{:?}", values_res)
+    //println!("{:?}", values_res)
 }