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);
 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);
 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                    );
 83                })
 84            })
 85        });
 86    });
 87}
 88
 89#[test]
 90fn gglwe_switching_key_keyswitch_inplace() {
 91    let log_n: usize = 8;
 92    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 93    let basek: usize = 12;
 94    let k_ct: usize = 60;
 95    let digits: usize = k_ct.div_ceil(basek);
 96    (1..4).for_each(|rank_in_s0s1| {
 97        (1..4).for_each(|rank_out_s0s1| {
 98            (1..digits + 1).for_each(|di| {
 99                let k_ksk: usize = k_ct + basek * di;
100                println!(
101                    "test_gglwe_switching_key_keyswitch_inplace digits: {} ranks: ({},{})",
102                    di, rank_in_s0s1, rank_out_s0s1
103                );
104                test_gglwe_switching_key_keyswitch_inplace(&module, basek, k_ct, k_ksk, di, rank_in_s0s1, rank_out_s0s1);
105            });
106        });
107    });
108}
109
110#[test]
111fn gglwe_switching_key_external_product() {
112    let log_n: usize = 8;
113    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
114    let basek: usize = 12;
115    let k_in: usize = 60;
116    let digits: usize = k_in.div_ceil(basek);
117    (1..4).for_each(|rank_in| {
118        (1..4).for_each(|rank_out| {
119            (1..digits + 1).for_each(|di| {
120                let k_ggsw: usize = k_in + basek * di;
121                println!(
122                    "test_gglwe_switching_key_external_product digits: {} ranks: ({} {})",
123                    di, rank_in, rank_out
124                );
125                let k_out: usize = k_in; // Better capture noise.
126                test_gglwe_switching_key_external_product(&module, basek, k_out, k_in, k_ggsw, di, rank_in, rank_out);
127            });
128        });
129    });
130}
131
132#[test]
133fn gglwe_switching_key_external_product_inplace() {
134    let log_n: usize = 5;
135    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
136    let basek: usize = 12;
137    let k_ct: usize = 60;
138    let digits: usize = k_ct.div_ceil(basek);
139    (1..4).for_each(|rank_in| {
140        (1..4).for_each(|rank_out| {
141            (1..digits).for_each(|di| {
142                let k_ggsw: usize = k_ct + basek * di;
143                println!(
144                    "test_gglwe_switching_key_external_product_inplace digits: {} ranks: ({} {})",
145                    di, rank_in, rank_out
146                );
147                test_gglwe_switching_key_external_product_inplace(&module, basek, k_ct, k_ggsw, di, rank_in, rank_out);
148            });
149        });
150    });
151}
152
153#[test]
154fn gglwe_automorphisk_key_encrypt_sk() {
155    let log_n: usize = 8;
156    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
157    let basek: usize = 12;
158    let k: usize = 60;
159    let digits: usize = k.div_ceil(basek) - 1;
160    (1..4).for_each(|rank| {
161        (2..digits + 1).for_each(|di| {
162            println!(
163                "test_gglwe_automorphisk_key_encrypt_sk digits: {} rank: {}",
164                di, rank
165            );
166            test_gglwe_automorphisk_key_encrypt_sk(&module, basek, k, di, rank);
167        });
168    });
169}
170
171#[test]
172fn gglwe_automorphisk_key_compressed_encrypt_sk() {
173    let log_n: usize = 8;
174    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
175    let basek: usize = 12;
176    let k: usize = 60;
177    let digits: usize = k.div_ceil(basek) - 1;
178    (1..4).for_each(|rank| {
179        (2..digits + 1).for_each(|di| {
180            println!(
181                "test_gglwe_automorphisk_key_compressed_encrypt_sk digits: {} rank: {}",
182                di, rank
183            );
184            test_gglwe_automorphisk_key_compressed_encrypt_sk(&module, basek, k, di, rank);
185        });
186    });
187}
188
189#[test]
190fn gglwe_automorphism_key_automorphism() {
191    let log_n: usize = 8;
192    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
193    let basek: usize = 12;
194    let k_in: usize = 60;
195    let k_out: usize = 40;
196    let digits: usize = k_in.div_ceil(basek);
197    (1..4).for_each(|rank| {
198        (2..digits + 1).for_each(|di| {
199            println!(
200                "test_gglwe_automorphism_key_automorphism: {} rank: {}",
201                di, rank
202            );
203            let k_apply: usize = (digits + di) * basek;
204            test_gglwe_automorphism_key_automorphism(&module, -1, 5, basek, di, k_in, k_out, k_apply, rank);
205        });
206    });
207}
208
209#[test]
210fn gglwe_automorphism_key_automorphism_inplace() {
211    let log_n: usize = 8;
212    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
213    let basek: usize = 12;
214    let k_in: usize = 60;
215    let digits: usize = k_in.div_ceil(basek);
216    (1..4).for_each(|rank| {
217        (2..digits + 1).for_each(|di| {
218            println!(
219                "test_gglwe_automorphism_key_automorphism_inplace: {} rank: {}",
220                di, rank
221            );
222            let k_apply: usize = (digits + di) * basek;
223            test_gglwe_automorphism_key_automorphism_inplace(&module, -1, 5, basek, di, k_in, k_apply, rank);
224        });
225    });
226}
227
228#[test]
229fn glwe_tensor_key_encrypt_sk() {
230    let log_n: usize = 8;
231    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
232    (1..4).for_each(|rank| {
233        println!("test_glwe_tensor_key_encrypt_sk rank: {}", rank);
234        test_glwe_tensor_key_encrypt_sk(&module, 16, 54, rank);
235    });
236}
237
238#[test]
239fn glwe_tensor_key_compressed_encrypt_sk() {
240    let log_n: usize = 8;
241    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
242    (1..4).for_each(|rank| {
243        println!("test_glwe_tensor_key_compressed_encrypt_sk rank: {}", rank);
244        test_glwe_tensor_key_compressed_encrypt_sk(&module, 16, 54, rank);
245    });
246}