1use backend::{
  2    hal::{api::ModuleNew, layouts::Module},
  3    implementation::cpu_spqlios::FFT64,
  4};
  5
  6use crate::gglwe::test::gglwe_generic::{
  7    test_encrypt_sk, test_external_product, test_external_product_inplace, test_keyswitch, test_keyswitch_inplace,
  8};
  9
 10#[test]
 11fn encrypt_sk() {
 12    let log_n: usize = 8;
 13    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 14    let basek: usize = 12;
 15    let k_ksk: usize = 54;
 16    let digits: usize = k_ksk / basek;
 17    (1..4).for_each(|rank_in| {
 18        (1..4).for_each(|rank_out| {
 19            (1..digits + 1).for_each(|di| {
 20                println!(
 21                    "test encrypt_sk digits: {} ranks: ({} {})",
 22                    di, rank_in, rank_out
 23                );
 24                test_encrypt_sk(&module, basek, k_ksk, di, rank_in, rank_out, 3.2);
 25            });
 26        });
 27    });
 28}
 29
 30#[test]
 31fn keyswitch() {
 32    let log_n: usize = 8;
 33    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 34    let basek: usize = 12;
 35    let k_in: usize = 60;
 36    let digits: usize = k_in.div_ceil(basek);
 37    (1..4).for_each(|rank_in_s0s1| {
 38        (1..4).for_each(|rank_out_s0s1| {
 39            (1..4).for_each(|rank_out_s1s2| {
 40                (1..digits + 1).for_each(|di| {
 41                    let k_ksk: usize = k_in + basek * di;
 42                    println!(
 43                        "test key_switch digits: {} ranks: ({},{},{})",
 44                        di, rank_in_s0s1, rank_out_s0s1, rank_out_s1s2
 45                    );
 46                    let k_out: usize = k_ksk; // Better capture noise.
 47                    test_keyswitch(
 48                        &module,
 49                        basek,
 50                        k_out,
 51                        k_in,
 52                        k_ksk,
 53                        di,
 54                        rank_in_s0s1,
 55                        rank_out_s0s1,
 56                        rank_out_s1s2,
 57                        3.2,
 58                    );
 59                })
 60            })
 61        });
 62    });
 63}
 64
 65#[test]
 66fn keyswitch_inplace() {
 67    let log_n: usize = 8;
 68    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 69    let basek: usize = 12;
 70    let k_ct: usize = 60;
 71    let digits: usize = k_ct.div_ceil(basek);
 72    (1..4).for_each(|rank_in_s0s1| {
 73        (1..4).for_each(|rank_out_s0s1| {
 74            (1..digits + 1).for_each(|di| {
 75                let k_ksk: usize = k_ct + basek * di;
 76                println!(
 77                    "test key_switch_inplace digits: {} ranks: ({},{})",
 78                    di, rank_in_s0s1, rank_out_s0s1
 79                );
 80                test_keyswitch_inplace(
 81                    &module,
 82                    basek,
 83                    k_ct,
 84                    k_ksk,
 85                    di,
 86                    rank_in_s0s1,
 87                    rank_out_s0s1,
 88                    3.2,
 89                );
 90            });
 91        });
 92    });
 93}
 94
 95#[test]
 96fn external_product() {
 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_in: usize = 60;
101    let digits: usize = k_in.div_ceil(basek);
102    (1..4).for_each(|rank_in| {
103        (1..4).for_each(|rank_out| {
104            (1..digits + 1).for_each(|di| {
105                let k_ggsw: usize = k_in + basek * di;
106                println!(
107                    "test external_product digits: {} ranks: ({} {})",
108                    di, rank_in, rank_out
109                );
110                let k_out: usize = k_in; // Better capture noise.
111                test_external_product(
112                    &module, basek, k_out, k_in, k_ggsw, di, rank_in, rank_out, 3.2,
113                );
114            });
115        });
116    });
117}
118
119#[test]
120fn external_product_inplace() {
121    let log_n: usize = 5;
122    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
123    let basek: usize = 12;
124    let k_ct: usize = 60;
125    let digits: usize = k_ct.div_ceil(basek);
126    (1..4).for_each(|rank_in| {
127        (1..4).for_each(|rank_out| {
128            (1..digits).for_each(|di| {
129                let k_ggsw: usize = k_ct + basek * di;
130                println!(
131                    "test external_product_inplace digits: {} ranks: ({} {})",
132                    di, rank_in, rank_out
133                );
134                test_external_product_inplace(&module, basek, k_ct, k_ggsw, di, rank_in, rank_out, 3.2);
135            });
136        });
137    });
138}