1use backend::{
  2    hal::{api::ModuleNew, layouts::Module},
  3    implementation::cpu_spqlios::FFT64,
  4};
  5
  6use crate::tests::generics::{
  7    automorphism::{test_gglwe_automorphism_key_automorphism, test_gglwe_automorphism_key_automorphism_inplace},
  8    encryption::{
  9        test_gglwe_automorphisk_key_compressed_encrypt_sk, test_gglwe_automorphisk_key_encrypt_sk,
 10        test_gglwe_switching_key_compressed_encrypt_sk, test_gglwe_switching_key_encrypt_sk,
 11        test_glwe_tensor_key_compressed_encrypt_sk, test_glwe_tensor_key_encrypt_sk,
 12    },
 13    external_product::{test_gglwe_switching_key_external_product, test_gglwe_switching_key_external_product_inplace},
 14    keyswitch::{test_gglwe_switching_key_keyswitch, test_gglwe_switching_key_keyswitch_inplace},
 15};
 16
 17#[test]
 18fn gglwe_switching_key_encrypt_sk() {
 19    let log_n: usize = 8;
 20    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 21    let basek: usize = 12;
 22    let k_ksk: usize = 54;
 23    let digits: usize = k_ksk / basek;
 24    (1..4).for_each(|rank_in| {
 25        (1..4).for_each(|rank_out| {
 26            (1..digits + 1).for_each(|di| {
 27                println!(
 28                    "test_gglwe_switching_key_encrypt_sk digits: {} ranks: ({} {})",
 29                    di, rank_in, rank_out
 30                );
 31                test_gglwe_switching_key_encrypt_sk(&module, basek, k_ksk, di, rank_in, rank_out, 3.2);
 32            });
 33        });
 34    });
 35}
 36
 37#[test]
 38fn gglwe_switching_key_compressed_encrypt_sk() {
 39    let log_n: usize = 8;
 40    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 41    let basek: usize = 12;
 42    let k_ksk: usize = 54;
 43    let digits: usize = k_ksk / basek;
 44    (1..4).for_each(|rank_in| {
 45        (1..4).for_each(|rank_out| {
 46            (1..digits + 1).for_each(|di| {
 47                println!(
 48                    "test_gglwe_switching_key_compressed_encrypt_sk digits: {} ranks: ({} {})",
 49                    di, rank_in, rank_out
 50                );
 51                test_gglwe_switching_key_compressed_encrypt_sk(&module, basek, k_ksk, di, rank_in, rank_out, 3.2);
 52            });
 53        });
 54    });
 55}
 56
 57#[test]
 58fn gglwe_switching_key_keyswitch() {
 59    let log_n: usize = 8;
 60    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 61    let basek: usize = 12;
 62    let k_in: usize = 60;
 63    let digits: usize = k_in.div_ceil(basek);
 64    (1..4).for_each(|rank_in_s0s1| {
 65        (1..4).for_each(|rank_out_s0s1| {
 66            (1..4).for_each(|rank_out_s1s2| {
 67                (1..digits + 1).for_each(|di| {
 68                    let k_ksk: usize = k_in + basek * di;
 69                    println!(
 70                        "test_gglwe_switching_key_keyswitch digits: {} ranks: ({},{},{})",
 71                        di, rank_in_s0s1, rank_out_s0s1, rank_out_s1s2
 72                    );
 73                    let k_out: usize = k_ksk; // Better capture noise.
 74                    test_gglwe_switching_key_keyswitch(
 75                        &module,
 76                        basek,
 77                        k_out,
 78                        k_in,
 79                        k_ksk,
 80                        di,
 81                        rank_in_s0s1,
 82                        rank_out_s0s1,
 83                        rank_out_s1s2,
 84                        3.2,
 85                    );
 86                })
 87            })
 88        });
 89    });
 90}
 91
 92#[test]
 93fn gglwe_switching_key_keyswitch_inplace() {
 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_ct: usize = 60;
 98    let digits: usize = k_ct.div_ceil(basek);
 99    (1..4).for_each(|rank_in_s0s1| {
100        (1..4).for_each(|rank_out_s0s1| {
101            (1..digits + 1).for_each(|di| {
102                let k_ksk: usize = k_ct + basek * di;
103                println!(
104                    "test_gglwe_switching_key_keyswitch_inplace digits: {} ranks: ({},{})",
105                    di, rank_in_s0s1, rank_out_s0s1
106                );
107                test_gglwe_switching_key_keyswitch_inplace(
108                    &module,
109                    basek,
110                    k_ct,
111                    k_ksk,
112                    di,
113                    rank_in_s0s1,
114                    rank_out_s0s1,
115                    3.2,
116                );
117            });
118        });
119    });
120}
121
122#[test]
123fn gglwe_switching_key_external_product() {
124    let log_n: usize = 8;
125    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
126    let basek: usize = 12;
127    let k_in: usize = 60;
128    let digits: usize = k_in.div_ceil(basek);
129    (1..4).for_each(|rank_in| {
130        (1..4).for_each(|rank_out| {
131            (1..digits + 1).for_each(|di| {
132                let k_ggsw: usize = k_in + basek * di;
133                println!(
134                    "test_gglwe_switching_key_external_product digits: {} ranks: ({} {})",
135                    di, rank_in, rank_out
136                );
137                let k_out: usize = k_in; // Better capture noise.
138                test_gglwe_switching_key_external_product(
139                    &module, basek, k_out, k_in, k_ggsw, di, rank_in, rank_out, 3.2,
140                );
141            });
142        });
143    });
144}
145
146#[test]
147fn gglwe_switching_key_external_product_inplace() {
148    let log_n: usize = 5;
149    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
150    let basek: usize = 12;
151    let k_ct: usize = 60;
152    let digits: usize = k_ct.div_ceil(basek);
153    (1..4).for_each(|rank_in| {
154        (1..4).for_each(|rank_out| {
155            (1..digits).for_each(|di| {
156                let k_ggsw: usize = k_ct + basek * di;
157                println!(
158                    "test_gglwe_switching_key_external_product_inplace digits: {} ranks: ({} {})",
159                    di, rank_in, rank_out
160                );
161                test_gglwe_switching_key_external_product_inplace(&module, basek, k_ct, k_ggsw, di, rank_in, rank_out, 3.2);
162            });
163        });
164    });
165}
166
167#[test]
168fn gglwe_automorphisk_key_encrypt_sk() {
169    let log_n: usize = 8;
170    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
171    let basek: usize = 12;
172    let k: usize = 60;
173    let digits: usize = k.div_ceil(basek) - 1;
174    let sigma: f64 = 3.2;
175    (1..4).for_each(|rank| {
176        (2..digits + 1).for_each(|di| {
177            println!(
178                "test_gglwe_automorphisk_key_encrypt_sk digits: {} rank: {}",
179                di, rank
180            );
181            test_gglwe_automorphisk_key_encrypt_sk(&module, basek, k, di, rank, sigma);
182        });
183    });
184}
185
186#[test]
187fn gglwe_automorphisk_key_compressed_encrypt_sk() {
188    let log_n: usize = 8;
189    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
190    let basek: usize = 12;
191    let k: usize = 60;
192    let digits: usize = k.div_ceil(basek) - 1;
193    let sigma: f64 = 3.2;
194    (1..4).for_each(|rank| {
195        (2..digits + 1).for_each(|di| {
196            println!(
197                "test_gglwe_automorphisk_key_compressed_encrypt_sk digits: {} rank: {}",
198                di, rank
199            );
200            test_gglwe_automorphisk_key_compressed_encrypt_sk(&module, basek, k, di, rank, sigma);
201        });
202    });
203}
204
205#[test]
206fn gglwe_automorphism_key_automorphism() {
207    let log_n: usize = 8;
208    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
209    let basek: usize = 12;
210    let k_in: usize = 60;
211    let k_out: usize = 40;
212    let digits: usize = k_in.div_ceil(basek);
213    let sigma: f64 = 3.2;
214    (1..4).for_each(|rank| {
215        (2..digits + 1).for_each(|di| {
216            println!(
217                "test_gglwe_automorphism_key_automorphism: {} rank: {}",
218                di, rank
219            );
220            let k_apply: usize = (digits + di) * basek;
221            test_gglwe_automorphism_key_automorphism(&module, -1, 5, basek, di, k_in, k_out, k_apply, sigma, rank);
222        });
223    });
224}
225
226#[test]
227fn gglwe_automorphism_key_automorphism_inplace() {
228    let log_n: usize = 8;
229    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
230    let basek: usize = 12;
231    let k_in: usize = 60;
232    let digits: usize = k_in.div_ceil(basek);
233    let sigma: f64 = 3.2;
234    (1..4).for_each(|rank| {
235        (2..digits + 1).for_each(|di| {
236            println!(
237                "test_gglwe_automorphism_key_automorphism_inplace: {} rank: {}",
238                di, rank
239            );
240            let k_apply: usize = (digits + di) * basek;
241            test_gglwe_automorphism_key_automorphism_inplace(&module, -1, 5, basek, di, k_in, k_apply, sigma, rank);
242        });
243    });
244}
245
246#[test]
247fn glwe_tensor_key_encrypt_sk() {
248    let log_n: usize = 8;
249    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
250    (1..4).for_each(|rank| {
251        println!("test_glwe_tensor_key_encrypt_sk rank: {}", rank);
252        test_glwe_tensor_key_encrypt_sk(&module, 16, 54, 3.2, rank);
253    });
254}
255
256#[test]
257fn glwe_tensor_key_compressed_encrypt_sk() {
258    let log_n: usize = 8;
259    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
260    (1..4).for_each(|rank| {
261        println!("test_glwe_tensor_key_compressed_encrypt_sk rank: {}", rank);
262        test_glwe_tensor_key_compressed_encrypt_sk(&module, 16, 54, 3.2, rank);
263    });
264}