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