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