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