1use crate::hal::{
 2    api::{VecZnxAddNormal, VecZnxFillUniform, ZnxView},
 3    layouts::{Backend, Module, VecZnx},
 4    source::Source,
 5};
 6
 7pub fn test_vec_znx_fill_uniform<B: Backend>(module: &Module<B>)
 8where
 9    Module<B>: VecZnxFillUniform,
10{
11    let n: usize = module.n();
12    let basek: usize = 17;
13    let size: usize = 5;
14    let mut source: Source = Source::new([0u8; 32]);
15    let cols: usize = 2;
16    let zero: Vec<i64> = vec![0; n];
17    let one_12_sqrt: f64 = 0.28867513459481287;
18    (0..cols).for_each(|col_i| {
19        let mut a: VecZnx<_> = VecZnx::alloc(n, cols, size);
20        module.vec_znx_fill_uniform(basek, &mut a, col_i, size * basek, &mut source);
21        (0..cols).for_each(|col_j| {
22            if col_j != col_i {
23                (0..size).for_each(|limb_i| {
24                    assert_eq!(a.at(col_j, limb_i), zero);
25                })
26            } else {
27                let std: f64 = a.std(basek, col_i);
28                assert!(
29                    (std - one_12_sqrt).abs() < 0.01,
30                    "std={} ~!= {}",
31                    std,
32                    one_12_sqrt
33                );
34            }
35        })
36    });
37}
38
39pub fn test_vec_znx_add_normal<B: Backend>(module: &Module<B>)
40where
41    Module<B>: VecZnxAddNormal,
42{
43    let n: usize = module.n();
44    let basek: usize = 17;
45    let k: usize = 2 * 17;
46    let size: usize = 5;
47    let sigma: f64 = 3.2;
48    let bound: f64 = 6.0 * sigma;
49    let mut source: Source = Source::new([0u8; 32]);
50    let cols: usize = 2;
51    let zero: Vec<i64> = vec![0; n];
52    let k_f64: f64 = (1u64 << k as u64) as f64;
53    (0..cols).for_each(|col_i| {
54        let mut a: VecZnx<_> = VecZnx::alloc(n, cols, size);
55        module.vec_znx_add_normal(basek, &mut a, col_i, k, &mut source, sigma, bound);
56        (0..cols).for_each(|col_j| {
57            if col_j != col_i {
58                (0..size).for_each(|limb_i| {
59                    assert_eq!(a.at(col_j, limb_i), zero);
60                })
61            } else {
62                let std: f64 = a.std(basek, col_i) * k_f64;
63                assert!((std - sigma).abs() < 0.1, "std={} ~!= {}", std, sigma);
64            }
65        })
66    });
67}