1use backend::{
  2    hal::{api::ModuleNew, layouts::Module},
  3    implementation::cpu_spqlios::FFT64,
  4};
  5
  6use crate::glwe::tests::{
  7    generic_automorphism::{test_automorphism, test_automorphism_inplace},
  8    generic_encryption::{test_encrypt_pk, test_encrypt_sk, test_encrypt_sk_compressed, test_encrypt_zero_sk},
  9    generic_external_product::{test_external_product, test_external_product_inplace},
 10    generic_keyswitch::{test_keyswitch, test_keyswitch_inplace},
 11    packing::test_packing,
 12    trace::test_trace_inplace,
 13};
 14
 15#[test]
 16fn encrypt_sk() {
 17    let log_n: usize = 8;
 18    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 19    (1..4).for_each(|rank| {
 20        println!("test encrypt_sk rank: {}", rank);
 21        test_encrypt_sk(&module, 8, 54, 30, 3.2, rank);
 22    });
 23}
 24
 25#[test]
 26fn encrypt_sk_compressed() {
 27    let log_n: usize = 8;
 28    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 29    (1..4).for_each(|rank| {
 30        println!("test encrypt_sk rank: {}", rank);
 31        test_encrypt_sk_compressed(&module, 8, 54, 30, 3.2, rank);
 32    });
 33}
 34
 35#[test]
 36fn encrypt_zero_sk() {
 37    let log_n: usize = 8;
 38    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 39    (1..4).for_each(|rank| {
 40        println!("test encrypt_zero_sk rank: {}", rank);
 41        test_encrypt_zero_sk(&module, 8, 64, 3.2, rank);
 42    });
 43}
 44
 45#[test]
 46fn encrypt_pk() {
 47    let log_n: usize = 8;
 48    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 49    (1..4).for_each(|rank| {
 50        println!("test encrypt_pk rank: {}", rank);
 51        test_encrypt_pk(&module, 8, 64, 64, 3.2, rank)
 52    });
 53}
 54
 55#[test]
 56fn apply() {
 57    let log_n: usize = 8;
 58    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 59    let basek: usize = 12;
 60    let k_in: usize = 45;
 61    let digits: usize = k_in.div_ceil(basek);
 62    (1..4).for_each(|rank_in| {
 63        (1..4).for_each(|rank_out| {
 64            (1..digits + 1).for_each(|di| {
 65                let k_ksk: usize = k_in + basek * di;
 66                let k_out: usize = k_ksk; // better capture noise
 67                println!(
 68                    "test keyswitch digits: {} rank_in: {} rank_out: {}",
 69                    di, rank_in, rank_out
 70                );
 71                test_keyswitch(
 72                    &module, basek, k_out, k_in, k_ksk, di, rank_in, rank_out, 3.2,
 73                );
 74            })
 75        });
 76    });
 77}
 78
 79#[test]
 80fn apply_inplace() {
 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_ct: usize = 45;
 85    let digits: usize = k_ct.div_ceil(basek);
 86    (1..4).for_each(|rank| {
 87        (1..digits + 1).for_each(|di| {
 88            let k_ksk: usize = k_ct + basek * di;
 89            println!("test keyswitch_inplace digits: {} rank: {}", di, rank);
 90            test_keyswitch_inplace(&module, basek, k_ct, k_ksk, di, rank, 3.2);
 91        });
 92    });
 93}
 94
 95#[test]
 96fn automorphism_inplace() {
 97    let log_n: usize = 8;
 98    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 99    let basek: usize = 12;
100    let k_ct: usize = 60;
101    let digits: usize = k_ct.div_ceil(basek);
102    (1..4).for_each(|rank| {
103        (1..digits + 1).for_each(|di| {
104            let k_ksk: usize = k_ct + basek * di;
105            println!("test automorphism_inplace digits: {} rank: {}", di, rank);
106            test_automorphism_inplace(&module, basek, -5, k_ct, k_ksk, di, rank, 3.2);
107        });
108    });
109}
110
111#[test]
112fn automorphism() {
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_in: usize = 60;
117    let digits: usize = k_in.div_ceil(basek);
118    (1..4).for_each(|rank| {
119        (1..digits + 1).for_each(|di| {
120            let k_ksk: usize = k_in + basek * di;
121            let k_out: usize = k_ksk; // Better capture noise.
122            println!("test automorphism digits: {} rank: {}", di, rank);
123            test_automorphism(&module, basek, -5, k_out, k_in, k_ksk, di, rank, 3.2);
124        })
125    });
126}
127
128#[test]
129fn 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 external_product digits: {} rank: {}", di, rank);
140            test_external_product(&module, basek, k_out, k_in, k_ggsw, di, rank, 3.2);
141        });
142    });
143}
144
145#[test]
146fn 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!("test external_product digits: {} rank: {}", di, rank);
156            test_external_product_inplace(&module, basek, k_ct, k_ggsw, di, rank, 3.2);
157        });
158    });
159}
160
161#[test]
162fn trace_inplace() {
163    let log_n: usize = 8;
164    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
165    (1..4).for_each(|rank| {
166        println!("test trace_inplace rank: {}", rank);
167        test_trace_inplace(&module, 8, 54, 3.2, rank);
168    });
169}
170
171#[test]
172fn packing() {
173    let log_n: usize = 5;
174    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
175    test_packing(&module);
176}