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