prototype trait for Elem<T> + new ciphertext for VmPPmat

base2k/examples/rlwe_encrypt.rs

@@ -8,9 +8,9 @@ use sampling::source::Source;
 fn main() {
     let n: usize = 16;
     let log_base2k: usize = 18;
-    let limbs: usize = 3;
-    let msg_limbs: usize = 2;
-    let log_scale: usize = msg_limbs * log_base2k - 5;
+    let cols: usize = 3;
+    let msg_cols: usize = 2;
+    let log_scale: usize = msg_cols * log_base2k - 5;
     let module: Module = Module::new::<FFT64>(n);
 
     let mut carry: Vec<u8> = vec![0; module.vec_znx_big_normalize_tmp_bytes()];
@@ -18,7 +18,7 @@ fn main() {
     let seed: [u8; 32] = [0; 32];
     let mut source: Source = Source::new(seed);
 
-    let mut res: VecZnx = module.new_vec_znx(limbs);
+    let mut res: VecZnx = module.new_vec_znx(cols);
 
     // s <- Z_{-1, 0, 1}[X]/(X^{N}+1)
     let mut s: Scalar = Scalar::new(n);
@@ -31,22 +31,22 @@ fn main() {
     module.svp_prepare(&mut s_ppol, &s);
 
     // a <- Z_{2^prec}[X]/(X^{N}+1)
-    let mut a: VecZnx = module.new_vec_znx(limbs);
-    module.fill_uniform(log_base2k, &mut a, limbs, &mut source);
+    let mut a: VecZnx = module.new_vec_znx(cols);
+    module.fill_uniform(log_base2k, &mut a, cols, &mut source);
 
     // Scratch space for DFT values
-    let mut buf_dft: VecZnxDft = module.new_vec_znx_dft(a.limbs());
+    let mut buf_dft: VecZnxDft = module.new_vec_znx_dft(a.cols());
 
     // Applies buf_dft <- s * a
-    module.svp_apply_dft(&mut buf_dft, &s_ppol, &a, a.limbs());
+    module.svp_apply_dft(&mut buf_dft, &s_ppol, &a, a.cols());
 
     // Alias scratch space
     let mut buf_big: VecZnxBig = buf_dft.as_vec_znx_big();
 
     // buf_big <- IDFT(buf_dft) (not normalized)
-    module.vec_znx_idft_tmp_a(&mut buf_big, &mut buf_dft, a.limbs());
+    module.vec_znx_idft_tmp_a(&mut buf_big, &mut buf_dft, a.cols());
 
-    let mut m: VecZnx = module.new_vec_znx(msg_limbs);
+    let mut m: VecZnx = module.new_vec_znx(msg_cols);
 
     let mut want: Vec<i64> = vec![0; n];
     want.iter_mut()
@@ -60,12 +60,12 @@ fn main() {
     module.vec_znx_big_sub_small_a_inplace(&mut buf_big, &m);
 
     // b <- normalize(buf_big) + e
-    let mut b: VecZnx = module.new_vec_znx(limbs);
+    let mut b: VecZnx = module.new_vec_znx(cols);
     module.vec_znx_big_normalize(log_base2k, &mut b, &buf_big, &mut carry);
     module.add_normal(
         log_base2k,
         &mut b,
-        log_base2k * limbs,
+        log_base2k * cols,
         &mut source,
         3.2,
         19.0,
@@ -74,8 +74,8 @@ fn main() {
     //Decrypt
 
     // buf_big <- a * s
-    module.svp_apply_dft(&mut buf_dft, &s_ppol, &a, a.limbs());
-    module.vec_znx_idft_tmp_a(&mut buf_big, &mut buf_dft, b.limbs());
+    module.svp_apply_dft(&mut buf_dft, &s_ppol, &a, a.cols());
+    module.vec_znx_idft_tmp_a(&mut buf_big, &mut buf_dft, b.cols());
 
     // buf_big <- a * s + b
     module.vec_znx_big_add_small_inplace(&mut buf_big, &b);
@@ -85,9 +85,9 @@ fn main() {
 
     // have = m * 2^{log_scale} + e
     let mut have: Vec<i64> = vec![i64::default(); n];
-    res.decode_vec_i64(log_base2k, res.limbs() * log_base2k, &mut have);
+    res.decode_vec_i64(log_base2k, res.cols() * log_base2k, &mut have);
 
-    let scale: f64 = (1 << (res.limbs() * log_base2k - log_scale)) as f64;
+    let scale: f64 = (1 << (res.cols() * log_base2k - log_scale)) as f64;
     izip!(want.iter(), have.iter())
         .enumerate()
         .for_each(|(i, (a, b))| {

base2k/examples/vector_matrix_product.rs

@@ -4,31 +4,31 @@ use base2k::{
 };
 
 fn main() {
-    let log_n = 5;
-    let n = 1 << log_n;
+    let log_n: i32 = 5;
+    let n: usize = 1 << log_n;
 
     let module: Module = Module::new::<FFT64>(n);
     let log_base2k: usize = 15;
-    let limbs: usize = 5;
-    let log_k: usize = log_base2k * limbs - 5;
+    let cols: usize = 5;
+    let log_k: usize = log_base2k * cols - 5;
 
-    let rows: usize = limbs;
-    let cols: usize = limbs + 1;
+    let rows: usize = cols;
+    let cols: usize = cols + 1;
 
     // Maximum size of the byte scratch needed
     let tmp_bytes: usize = module.vmp_prepare_tmp_bytes(rows, cols)
-        | module.vmp_apply_dft_tmp_bytes(limbs, limbs, rows, cols);
+        | module.vmp_apply_dft_tmp_bytes(cols, cols, rows, cols);
 
     let mut buf: Vec<u8> = vec![0; tmp_bytes];
 
     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(limbs);
+    let mut a: VecZnx = module.new_vec_znx(cols);
     a.encode_vec_i64(log_base2k, log_k, &a_values, 32);
     a.normalize(log_base2k, &mut buf);
 
-    a.print_limbs(a.limbs(), n);
+    a.print(a.cols(), n);
     println!();
 
     let mut vecznx: Vec<VecZnx> = Vec::new();
@@ -40,8 +40,10 @@ fn main() {
         vecznx[i].data[i * n + 1] = 1 as i64;
     });
 
+    let slices: Vec<&[i64]> = vecznx.iter().map(|v| v.data.as_slice()).collect();
+
     let mut vmp_pmat: VmpPMat = module.new_vmp_pmat(rows, cols);
-    module.vmp_prepare_dblptr(&mut vmp_pmat, &vecznx, &mut buf);
+    module.vmp_prepare_dblptr(&mut vmp_pmat, &slices, &mut buf);
 
     let mut c_dft: VecZnxDft = module.new_vec_znx_dft(cols);
     module.vmp_apply_dft(&mut c_dft, &a, &vmp_pmat, &mut buf);
@@ -55,7 +57,7 @@ fn main() {
     let mut values_res: Vec<i64> = vec![i64::default(); n];
     res.decode_vec_i64(log_base2k, log_k, &mut values_res);
 
-    res.print_limbs(res.limbs(), n);
+    res.print(res.cols(), n);
 
     module.free();
     c_dft.free();