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