1use poulpy_backend::cpu_spqlios::FFT64;
  2use poulpy_hal::{api::ModuleNew, layouts::Module};
  3
  4use crate::tests::generics::{
  5    automorphism::{test_ggsw_automorphism, test_ggsw_automorphism_inplace},
  6    encryption::{test_ggsw_compressed_encrypt_sk, test_ggsw_encrypt_sk},
  7    external_product::{test_ggsw_external_product, test_ggsw_external_product_inplace},
  8    keyswitch::{test_ggsw_keyswitch, test_ggsw_keyswitch_inplace},
  9};
 10
 11#[test]
 12fn ggsw_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_ggsw_encrypt_sk digits: {} rank: {}", di, rank);
 21            test_ggsw_encrypt_sk(&module, basek, k_ct, di, rank, 3.2);
 22        });
 23    });
 24}
 25
 26#[test]
 27fn ggsw_compressed_encrypt_sk() {
 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!(
 36                "test_ggsw_compressed_encrypt_sk digits: {} rank: {}",
 37                di, rank
 38            );
 39            test_ggsw_compressed_encrypt_sk(&module, basek, k_ct, di, rank, 3.2);
 40        });
 41    });
 42}
 43
 44#[test]
 45fn ggsw_keyswitch() {
 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_in: usize = 54;
 50    let digits: usize = k_in.div_ceil(basek);
 51    (1..4).for_each(|rank| {
 52        (1..digits + 1).for_each(|di| {
 53            let k_ksk: usize = k_in + basek * di;
 54            let k_tsk: usize = k_ksk;
 55            println!("test_ggsw_keyswitch digits: {} rank: {}", di, rank);
 56            let k_out: usize = k_ksk; // Better capture noise.
 57            test_ggsw_keyswitch(&module, basek, k_out, k_in, k_ksk, k_tsk, di, rank, 3.2);
 58        });
 59    });
 60}
 61
 62#[test]
 63fn ggsw_keyswitch_inplace() {
 64    let log_n: usize = 8;
 65    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 66    let basek: usize = 12;
 67    let k_ct: usize = 54;
 68    let digits: usize = k_ct.div_ceil(basek);
 69    (1..4).for_each(|rank| {
 70        (1..digits + 1).for_each(|di| {
 71            let k_ksk: usize = k_ct + basek * di;
 72            let k_tsk: usize = k_ksk;
 73            println!("test_ggsw_keyswitch_inplace digits: {} rank: {}", di, rank);
 74            test_ggsw_keyswitch_inplace(&module, basek, k_ct, k_ksk, k_tsk, di, rank, 3.2);
 75        });
 76    });
 77}
 78
 79#[test]
 80fn ggsw_automorphism() {
 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_in: usize = 54;
 85    let digits: usize = k_in.div_ceil(basek);
 86    (1..4).for_each(|rank| {
 87        (1..digits + 1).for_each(|di| {
 88            let k_ksk: usize = k_in + basek * di;
 89            let k_tsk: usize = k_ksk;
 90            println!("test_ggsw_automorphism rank: {}", rank);
 91            let k_out: usize = k_ksk; // Better capture noise.
 92            test_ggsw_automorphism(-5, &module, basek, k_out, k_in, k_ksk, k_tsk, di, rank, 3.2);
 93        });
 94    });
 95}
 96
 97#[test]
 98fn ggsw_automorphism_inplace() {
 99    let log_n: usize = 8;
100    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
101    let basek: usize = 12;
102    let k_ct: usize = 54;
103    let digits: usize = k_ct.div_ceil(basek);
104    (1..4).for_each(|rank| {
105        (1..digits + 1).for_each(|di| {
106            let k_ksk: usize = k_ct + basek * di;
107            let k_tsk: usize = k_ksk;
108            println!("test_ggsw_automorphism_inplace rank: {}", rank);
109            test_ggsw_automorphism_inplace(-5, &module, basek, k_ct, k_ksk, k_tsk, di, rank, 3.2);
110        });
111    });
112}
113
114#[test]
115fn ggsw_external_product() {
116    let log_n: usize = 8;
117    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
118    let basek: usize = 12;
119    let k_in: usize = 60;
120    let digits: usize = k_in.div_ceil(basek);
121    (1..4).for_each(|rank| {
122        (1..digits + 1).for_each(|di| {
123            let k_ggsw: usize = k_in + basek * di;
124            println!("test external_product digits: {} ranks: {}", di, rank);
125            let k_out: usize = k_in; // Better capture noise.
126            test_ggsw_external_product(&module, basek, k_in, k_out, k_ggsw, di, rank, 3.2);
127        });
128    });
129}
130
131#[test]
132fn ggsw_external_product_inplace() {
133    let log_n: usize = 8;
134    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
135    let basek: usize = 12;
136    let k_ct: usize = 60;
137    let digits: usize = k_ct.div_ceil(basek);
138    (1..4).for_each(|rank| {
139        (1..digits).for_each(|di| {
140            let k_ggsw: usize = k_ct + basek * di;
141            println!(
142                "test_ggsw_external_product_inplace digits: {} rank: {}",
143                di, rank
144            );
145            test_ggsw_external_product_inplace(&module, basek, k_ct, k_ggsw, di, rank, 3.2);
146        });
147    });
148}