1use base2k::{Module, Scalar, SvpPPol, VecZnx, VecZnxBig, VecZnxDft, FFT64};
 2use itertools::izip;
 3use sampling::source::Source;
 4
 5fn main() {
 6    let n: usize = 16;
 7    let log_base2k: usize = 18;
 8    let limbs: usize = 3;
 9    let msg_limbs: usize = 2;
10    let log_scale: usize = msg_limbs * log_base2k - 5;
11    let module: Module = Module::new::<FFT64>(n);
12
13    let mut carry: Vec<u8> = vec![0; module.vec_znx_big_normalize_tmp_bytes()];
14
15    let seed: [u8; 32] = [0; 32];
16    let mut source: Source = Source::new(seed);
17
18    let mut res: VecZnx = module.new_vec_znx(limbs);
19
20    // s <- Z_{-1, 0, 1}[X]/(X^{N}+1)
21    let mut s: Scalar = Scalar::new(n);
22    s.fill_ternary_prob(0.5, &mut source);
23
24    // Buffer to store s in the DFT domain
25    let mut s_ppol: SvpPPol = module.svp_new_ppol();
26
27    // s_ppol <- DFT(s)
28    module.svp_prepare(&mut s_ppol, &s);
29
30    // a <- Z_{2^prec}[X]/(X^{N}+1)
31    let mut a: VecZnx = module.new_vec_znx(limbs);
32    a.fill_uniform(log_base2k, &mut source, limbs);
33
34    // Scratch space for DFT values
35    let mut buf_dft: VecZnxDft = module.new_vec_znx_dft(a.limbs());
36
37    // Applies buf_dft <- s * a
38    module.svp_apply_dft(&mut buf_dft, &s_ppol, &a);
39
40    // Alias scratch space
41    let mut buf_big: VecZnxBig = buf_dft.as_vec_znx_big();
42
43    // buf_big <- IDFT(buf_dft) (not normalized)
44    module.vec_znx_idft_tmp_a(&mut buf_big, &mut buf_dft, a.limbs());
45
46    let mut m: VecZnx = module.new_vec_znx(msg_limbs);
47
48    let mut want: Vec<i64> = vec![0; n];
49    want.iter_mut()
50        .for_each(|x| *x = source.next_u64n(16, 15) as i64);
51
52    // m
53    m.from_i64(log_base2k, &want, 4, log_scale);
54    m.normalize(log_base2k, &mut carry);
55
56    // buf_big <- m - buf_big
57    module.vec_znx_big_sub_small_a_inplace(&mut buf_big, &m);
58
59    // b <- normalize(buf_big) + e
60    let mut b: VecZnx = module.new_vec_znx(limbs);
61    module.vec_znx_big_normalize(log_base2k, &mut b, &buf_big, &mut carry);
62    b.add_normal(log_base2k, &mut source, 3.2, 19.0, log_base2k * limbs);
63
64    //Decrypt
65
66    // buf_big <- a * s
67    module.svp_apply_dft(&mut buf_dft, &s_ppol, &a);
68    module.vec_znx_idft_tmp_a(&mut buf_big, &mut buf_dft, b.limbs());
69
70    // buf_big <- a * s + b
71    module.vec_znx_big_add_small_inplace(&mut buf_big, &b);
72
73    // res <- normalize(buf_big)
74    module.vec_znx_big_normalize(log_base2k, &mut res, &buf_big, &mut carry);
75
76    // have = m * 2^{log_scale} + e
77    let mut have: Vec<i64> = vec![i64::default(); n];
78    res.to_i64(log_base2k, &mut have, res.limbs() * log_base2k);
79
80    let scale: f64 = (1 << (res.limbs() * log_base2k - log_scale)) as f64;
81    izip!(want.iter(), have.iter())
82        .enumerate()
83        .for_each(|(i, (a, b))| {
84            println!("{}: {} {}", i, a, (*b as f64) / scale);
85        })
86}