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, 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, 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, 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, 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(&module, basek, k_out, k_in, k_ksk, di, rank_in, rank_out);
 69            })
 70        });
 71    });
 72}
 73
 74#[test]
 75fn glwe_keyswitch_inplace() {
 76    let log_n: usize = 8;
 77    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 78    let basek: usize = 12;
 79    let k_ct: usize = 45;
 80    let digits: usize = k_ct.div_ceil(basek);
 81    (1..4).for_each(|rank| {
 82        (1..digits + 1).for_each(|di| {
 83            let k_ksk: usize = k_ct + basek * di;
 84            println!("test_glwe_keyswitch_inplace digits: {} rank: {}", di, rank);
 85            test_glwe_keyswitch_inplace(&module, basek, k_ct, k_ksk, di, rank);
 86        });
 87    });
 88}
 89
 90#[test]
 91fn glwe_automorphism() {
 92    let log_n: usize = 8;
 93    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 94    let basek: usize = 12;
 95    let k_in: usize = 60;
 96    let digits: usize = k_in.div_ceil(basek);
 97    (1..4).for_each(|rank| {
 98        (1..digits + 1).for_each(|di| {
 99            let k_ksk: usize = k_in + basek * di;
100            let k_out: usize = k_ksk; // Better capture noise.
101            println!("test_glwe_automorphism digits: {} rank: {}", di, rank);
102            test_glwe_automorphism(&module, basek, -5, k_out, k_in, k_ksk, di, rank);
103        })
104    });
105}
106
107#[test]
108fn glwe_automorphism_inplace() {
109    let log_n: usize = 8;
110    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
111    let basek: usize = 12;
112    let k_ct: usize = 60;
113    let digits: usize = k_ct.div_ceil(basek);
114    (1..4).for_each(|rank| {
115        (1..digits + 1).for_each(|di| {
116            let k_ksk: usize = k_ct + basek * di;
117            println!(
118                "test_glwe_automorphism_inplace digits: {} rank: {}",
119                di, rank
120            );
121            test_glwe_automorphism_inplace(&module, basek, -5, k_ct, k_ksk, di, rank);
122        });
123    });
124}
125
126#[test]
127fn glwe_external_product() {
128    let log_n: usize = 8;
129    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
130    let basek: usize = 12;
131    let k_in: usize = 45;
132    let digits: usize = k_in.div_ceil(basek);
133    (1..4).for_each(|rank| {
134        (1..digits + 1).for_each(|di| {
135            let k_ggsw: usize = k_in + basek * di;
136            let k_out: usize = k_ggsw; // Better capture noise
137            println!("test_glwe_external_product digits: {} rank: {}", di, rank);
138            test_glwe_external_product(&module, basek, k_out, k_in, k_ggsw, di, rank);
139        });
140    });
141}
142
143#[test]
144fn glwe_external_product_inplace() {
145    let log_n: usize = 8;
146    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
147    let basek: usize = 12;
148    let k_ct: usize = 60;
149    let digits: usize = k_ct.div_ceil(basek);
150    (1..4).for_each(|rank| {
151        (1..digits + 1).for_each(|di| {
152            let k_ggsw: usize = k_ct + basek * di;
153            println!(
154                "test_glwe_external_product_inplace digits: {} rank: {}",
155                di, rank
156            );
157            test_glwe_external_product_inplace(&module, basek, k_ct, k_ggsw, di, rank);
158        });
159    });
160}
161
162#[test]
163fn glwe_trace_inplace() {
164    let log_n: usize = 8;
165    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
166    (1..4).for_each(|rank| {
167        println!("test_glwe_trace_inplace rank: {}", rank);
168        test_glwe_trace_inplace(&module, 8, 54, rank);
169    });
170}
171
172#[test]
173fn glwe_packing() {
174    let log_n: usize = 5;
175    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
176    test_glwe_packing(&module);
177}