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