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_encrypt_sk_compressed, test_external_product,
  8    test_external_product_inplace, 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 encrypt_sk_compressed() {
 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_ct: usize = 54;
 32    let digits: usize = k_ct / basek;
 33    (1..4).for_each(|rank| {
 34        (1..digits + 1).for_each(|di| {
 35            println!("test encrypt_sk_compressed digits: {} rank: {}", di, rank);
 36            test_encrypt_sk_compressed(&module, basek, k_ct, di, rank, 3.2);
 37        });
 38    });
 39}
 40
 41#[test]
 42fn keyswitch() {
 43    let log_n: usize = 8;
 44    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 45    let basek: usize = 12;
 46    let k_in: usize = 54;
 47    let digits: usize = k_in.div_ceil(basek);
 48    (1..4).for_each(|rank| {
 49        (1..digits + 1).for_each(|di| {
 50            let k_ksk: usize = k_in + basek * di;
 51            let k_tsk: usize = k_ksk;
 52            println!("test keyswitch digits: {} rank: {}", di, rank);
 53            let k_out: usize = k_ksk; // Better capture noise.
 54            test_keyswitch(&module, basek, k_out, k_in, k_ksk, k_tsk, di, rank, 3.2);
 55        });
 56    });
 57}
 58
 59#[test]
 60fn keyswitch_inplace() {
 61    let log_n: usize = 8;
 62    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 63    let basek: usize = 12;
 64    let k_ct: usize = 54;
 65    let digits: usize = k_ct.div_ceil(basek);
 66    (1..4).for_each(|rank| {
 67        (1..digits + 1).for_each(|di| {
 68            let k_ksk: usize = k_ct + basek * di;
 69            let k_tsk: usize = k_ksk;
 70            println!("test keyswitch_inplace digits: {} rank: {}", di, rank);
 71            test_keyswitch_inplace(&module, basek, k_ct, k_ksk, k_tsk, di, rank, 3.2);
 72        });
 73    });
 74}
 75
 76#[test]
 77fn automorphism() {
 78    let log_n: usize = 8;
 79    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 80    let basek: usize = 12;
 81    let k_in: usize = 54;
 82    let digits: usize = k_in.div_ceil(basek);
 83    (1..4).for_each(|rank| {
 84        (1..digits + 1).for_each(|di| {
 85            let k_ksk: usize = k_in + basek * di;
 86            let k_tsk: usize = k_ksk;
 87            println!("test automorphism rank: {}", rank);
 88            let k_out: usize = k_ksk; // Better capture noise.
 89            test_automorphism(-5, &module, basek, k_out, k_in, k_ksk, k_tsk, di, rank, 3.2);
 90        });
 91    });
 92}
 93
 94#[test]
 95fn automorphism_inplace() {
 96    let log_n: usize = 8;
 97    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 98    let basek: usize = 12;
 99    let k_ct: usize = 54;
100    let digits: usize = k_ct.div_ceil(basek);
101    (1..4).for_each(|rank| {
102        (1..digits + 1).for_each(|di| {
103            let k_ksk: usize = k_ct + basek * di;
104            let k_tsk: usize = k_ksk;
105            println!("test automorphism_inplace rank: {}", rank);
106            test_automorphism_inplace(-5, &module, basek, k_ct, k_ksk, k_tsk, di, rank, 3.2);
107        });
108    });
109}
110
111#[test]
112fn external_product() {
113    let log_n: usize = 8;
114    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
115    let basek: usize = 12;
116    let k_in: usize = 60;
117    let digits: usize = k_in.div_ceil(basek);
118    (1..4).for_each(|rank| {
119        (1..digits + 1).for_each(|di| {
120            let k_ggsw: usize = k_in + basek * di;
121            println!("test external_product digits: {} ranks: {}", di, rank);
122            let k_out: usize = k_in; // Better capture noise.
123            test_external_product(&module, basek, k_in, k_out, k_ggsw, di, rank, 3.2);
124        });
125    });
126}
127
128#[test]
129fn external_product_inplace() {
130    let log_n: usize = 8;
131    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
132    let basek: usize = 12;
133    let k_ct: usize = 60;
134    let digits: usize = k_ct.div_ceil(basek);
135    (1..4).for_each(|rank| {
136        (1..digits).for_each(|di| {
137            let k_ggsw: usize = k_ct + basek * di;
138            println!("test external_product digits: {} rank: {}", di, rank);
139            test_external_product_inplace(&module, basek, k_ct, k_ggsw, di, rank, 3.2);
140        });
141    });
142}