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