1use backend::{
  2    hal::{api::ModuleNew, layouts::Module},
  3    implementation::cpu_spqlios::FFT64,
  4};
  5
  6use crate::ggsw::test::generic_tests::{
  7    test_automorphism, test_automorphism_inplace, test_encrypt_sk, test_external_product, test_external_product_inplace,
  8    test_keyswitch, test_keyswitch_inplace,
  9};
 10
 11#[test]
 12fn encrypt_sk() {
 13    let log_n: usize = 8;
 14    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 15    let basek: usize = 12;
 16    let k_ct: usize = 54;
 17    let digits: usize = k_ct / basek;
 18    (1..4).for_each(|rank| {
 19        (1..digits + 1).for_each(|di| {
 20            println!("test encrypt_sk digits: {} rank: {}", di, rank);
 21            test_encrypt_sk(&module, basek, k_ct, di, rank, 3.2);
 22        });
 23    });
 24}
 25
 26#[test]
 27fn keyswitch() {
 28    let log_n: usize = 8;
 29    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 30    let basek: usize = 12;
 31    let k_in: usize = 54;
 32    let digits: usize = k_in.div_ceil(basek);
 33    (1..4).for_each(|rank| {
 34        (1..digits + 1).for_each(|di| {
 35            let k_ksk: usize = k_in + basek * di;
 36            let k_tsk: usize = k_ksk;
 37            println!("test keyswitch digits: {} rank: {}", di, rank);
 38            let k_out: usize = k_ksk; // Better capture noise.
 39            test_keyswitch(&module, basek, k_out, k_in, k_ksk, k_tsk, di, rank, 3.2);
 40        });
 41    });
 42}
 43
 44#[test]
 45fn keyswitch_inplace() {
 46    let log_n: usize = 8;
 47    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 48    let basek: usize = 12;
 49    let k_ct: usize = 54;
 50    let digits: usize = k_ct.div_ceil(basek);
 51    (1..4).for_each(|rank| {
 52        (1..digits + 1).for_each(|di| {
 53            let k_ksk: usize = k_ct + basek * di;
 54            let k_tsk: usize = k_ksk;
 55            println!("test keyswitch_inplace digits: {} rank: {}", di, rank);
 56            test_keyswitch_inplace(&module, basek, k_ct, k_ksk, k_tsk, di, rank, 3.2);
 57        });
 58    });
 59}
 60
 61#[test]
 62fn automorphism() {
 63    let log_n: usize = 8;
 64    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 65    let basek: usize = 12;
 66    let k_in: usize = 54;
 67    let digits: usize = k_in.div_ceil(basek);
 68    (1..4).for_each(|rank| {
 69        (1..digits + 1).for_each(|di| {
 70            let k_ksk: usize = k_in + basek * di;
 71            let k_tsk: usize = k_ksk;
 72            println!("test automorphism rank: {}", rank);
 73            let k_out: usize = k_ksk; // Better capture noise.
 74            test_automorphism(-5, &module, basek, k_out, k_in, k_ksk, k_tsk, di, rank, 3.2);
 75        });
 76    });
 77}
 78
 79#[test]
 80fn automorphism_inplace() {
 81    let log_n: usize = 8;
 82    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 83    let basek: usize = 12;
 84    let k_ct: usize = 54;
 85    let digits: usize = k_ct.div_ceil(basek);
 86    (1..4).for_each(|rank| {
 87        (1..digits + 1).for_each(|di| {
 88            let k_ksk: usize = k_ct + basek * di;
 89            let k_tsk: usize = k_ksk;
 90            println!("test automorphism_inplace rank: {}", rank);
 91            test_automorphism_inplace(-5, &module, basek, k_ct, k_ksk, k_tsk, di, rank, 3.2);
 92        });
 93    });
 94}
 95
 96#[test]
 97fn external_product() {
 98    let log_n: usize = 8;
 99    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
100    let basek: usize = 12;
101    let k_in: usize = 60;
102    let digits: usize = k_in.div_ceil(basek);
103    (1..4).for_each(|rank| {
104        (1..digits + 1).for_each(|di| {
105            let k_ggsw: usize = k_in + basek * di;
106            println!("test external_product digits: {} ranks: {}", di, rank);
107            let k_out: usize = k_in; // Better capture noise.
108            test_external_product(&module, basek, k_in, k_out, k_ggsw, di, rank, 3.2);
109        });
110    });
111}
112
113#[test]
114fn external_product_inplace() {
115    let log_n: usize = 8;
116    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
117    let basek: usize = 12;
118    let k_ct: usize = 60;
119    let digits: usize = k_ct.div_ceil(basek);
120    (1..4).for_each(|rank| {
121        (1..digits).for_each(|di| {
122            let k_ggsw: usize = k_ct + basek * di;
123            println!("test external_product digits: {} rank: {}", di, rank);
124            test_external_product_inplace(&module, basek, k_ct, k_ggsw, di, rank, 3.2);
125        });
126    });
127}