1use poulpy_backend::cpu_spqlios::FFT64;
  2use poulpy_hal::{api::ModuleNew, layouts::Module};
  3
  4use crate::tests::generics::{
  5    automorphism::{test_glwe_automorphism, test_glwe_automorphism_inplace},
  6    encryption::{test_glwe_compressed_encrypt_sk, test_glwe_encrypt_pk, test_glwe_encrypt_sk, test_glwe_encrypt_zero_sk},
  7    external_product::{test_glwe_external_product, test_glwe_external_product_inplace},
  8    keyswitch::{test_glwe_keyswitch, test_glwe_keyswitch_inplace},
  9    test_glwe_packing, test_glwe_trace_inplace,
 10};
 11
 12#[test]
 13fn glwe_encrypt_sk() {
 14    let log_n: usize = 8;
 15    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 16    (1..4).for_each(|rank| {
 17        println!("test_glwe_encrypt_sk rank: {}", rank);
 18        test_glwe_encrypt_sk(&module, 8, 54, 30, 3.2, rank);
 19    });
 20}
 21
 22#[test]
 23fn glwe_compressed_encrypt_sk() {
 24    let log_n: usize = 8;
 25    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 26    (1..4).for_each(|rank| {
 27        println!("test_glwe_compressed_encrypt_sk rank: {}", rank);
 28        test_glwe_compressed_encrypt_sk(&module, 8, 54, 30, 3.2, rank);
 29    });
 30}
 31
 32#[test]
 33fn glwe_encrypt_zero_sk() {
 34    let log_n: usize = 8;
 35    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 36    (1..4).for_each(|rank| {
 37        println!("test_glwe_encrypt_zero_sk rank: {}", rank);
 38        test_glwe_encrypt_zero_sk(&module, 8, 64, 3.2, rank);
 39    });
 40}
 41
 42#[test]
 43fn glwe_encrypt_pk() {
 44    let log_n: usize = 8;
 45    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 46    (1..4).for_each(|rank| {
 47        println!("test_glwe_encrypt_pk rank: {}", rank);
 48        test_glwe_encrypt_pk(&module, 8, 64, 64, 3.2, rank)
 49    });
 50}
 51
 52#[test]
 53fn glwe_keyswitch() {
 54    let log_n: usize = 8;
 55    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 56    let basek: usize = 12;
 57    let k_in: usize = 45;
 58    let digits: usize = k_in.div_ceil(basek);
 59    (1..4).for_each(|rank_in| {
 60        (1..4).for_each(|rank_out| {
 61            (1..digits + 1).for_each(|di| {
 62                let k_ksk: usize = k_in + basek * di;
 63                let k_out: usize = k_ksk; // better capture noise
 64                println!(
 65                    "test_glwe_keyswitch digits: {} rank_in: {} rank_out: {}",
 66                    di, rank_in, rank_out
 67                );
 68                test_glwe_keyswitch(
 69                    &module, basek, k_out, k_in, k_ksk, di, rank_in, rank_out, 3.2,
 70                );
 71            })
 72        });
 73    });
 74}
 75
 76#[test]
 77fn glwe_keyswitch_inplace() {
 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_ct: usize = 45;
 82    let digits: usize = k_ct.div_ceil(basek);
 83    (1..4).for_each(|rank| {
 84        (1..digits + 1).for_each(|di| {
 85            let k_ksk: usize = k_ct + basek * di;
 86            println!("test_glwe_keyswitch_inplace digits: {} rank: {}", di, rank);
 87            test_glwe_keyswitch_inplace(&module, basek, k_ct, k_ksk, di, rank, 3.2);
 88        });
 89    });
 90}
 91
 92#[test]
 93fn glwe_automorphism() {
 94    let log_n: usize = 8;
 95    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 96    let basek: usize = 12;
 97    let k_in: usize = 60;
 98    let digits: usize = k_in.div_ceil(basek);
 99    (1..4).for_each(|rank| {
100        (1..digits + 1).for_each(|di| {
101            let k_ksk: usize = k_in + basek * di;
102            let k_out: usize = k_ksk; // Better capture noise.
103            println!("test_glwe_automorphism digits: {} rank: {}", di, rank);
104            test_glwe_automorphism(&module, basek, -5, k_out, k_in, k_ksk, di, rank, 3.2);
105        })
106    });
107}
108
109#[test]
110fn glwe_automorphism_inplace() {
111    let log_n: usize = 8;
112    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
113    let basek: usize = 12;
114    let k_ct: usize = 60;
115    let digits: usize = k_ct.div_ceil(basek);
116    (1..4).for_each(|rank| {
117        (1..digits + 1).for_each(|di| {
118            let k_ksk: usize = k_ct + basek * di;
119            println!(
120                "test_glwe_automorphism_inplace digits: {} rank: {}",
121                di, rank
122            );
123            test_glwe_automorphism_inplace(&module, basek, -5, k_ct, k_ksk, di, rank, 3.2);
124        });
125    });
126}
127
128#[test]
129fn glwe_external_product() {
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_in: usize = 45;
134    let digits: usize = k_in.div_ceil(basek);
135    (1..4).for_each(|rank| {
136        (1..digits + 1).for_each(|di| {
137            let k_ggsw: usize = k_in + basek * di;
138            let k_out: usize = k_ggsw; // Better capture noise
139            println!("test_glwe_external_product digits: {} rank: {}", di, rank);
140            test_glwe_external_product(&module, basek, k_out, k_in, k_ggsw, di, rank, 3.2);
141        });
142    });
143}
144
145#[test]
146fn glwe_external_product_inplace() {
147    let log_n: usize = 8;
148    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
149    let basek: usize = 12;
150    let k_ct: usize = 60;
151    let digits: usize = k_ct.div_ceil(basek);
152    (1..4).for_each(|rank| {
153        (1..digits + 1).for_each(|di| {
154            let k_ggsw: usize = k_ct + basek * di;
155            println!(
156                "test_glwe_external_product_inplace digits: {} rank: {}",
157                di, rank
158            );
159            test_glwe_external_product_inplace(&module, basek, k_ct, k_ggsw, di, rank, 3.2);
160        });
161    });
162}
163
164#[test]
165fn glwe_trace_inplace() {
166    let log_n: usize = 8;
167    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
168    (1..4).for_each(|rank| {
169        println!("test_glwe_trace_inplace rank: {}", rank);
170        test_glwe_trace_inplace(&module, 8, 54, 3.2, rank);
171    });
172}
173
174#[test]
175fn glwe_packing() {
176    let log_n: usize = 5;
177    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
178    test_glwe_packing(&module);
179}