diff --git a/.gitmodules b/.gitmodules index 0fa69b7..a7f9b93 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,3 @@ -[submodule "base2k/spqlios-arithmetic"] - path = base2k/spqlios-arithmetic +[submodule "backend/spqlios-arithmetic"] + path = backend/spqlios-arithmetic url = https://github.com/phantomzone-org/spqlios-arithmetic diff --git a/.vscode/settings.json b/.vscode/settings.json index d32c5df..5ce22a6 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,71 +1,71 @@ -{ - "cmake.sourceDirectory": "C:/Users/boss_/go/src/github.com/gausslabs/fhe/base2k/spqlios-arithmetic", - "files.associations": { - "vector": "cpp", - "xstring": "cpp", - "xutility": "cpp", - "algorithm": "cpp", - "atomic": "cpp", - "bit": "cpp", - "cctype": "cpp", - "charconv": "cpp", - "cinttypes": "cpp", - "clocale": "cpp", - "cmath": "cpp", - "compare": "cpp", - "complex": "cpp", - "concepts": "cpp", - "cstddef": "cpp", - "cstdint": "cpp", - "cstdio": "cpp", - "cstdlib": "cpp", - "cstring": "cpp", - "ctime": "cpp", - "cwchar": "cpp", - "exception": "cpp", - "format": "cpp", - "initializer_list": "cpp", - "ios": "cpp", - "iosfwd": "cpp", - "iostream": "cpp", - "istream": "cpp", - "iterator": "cpp", - "limits": "cpp", - "locale": "cpp", - "memory": "cpp", - "new": "cpp", - "optional": "cpp", - "ostream": "cpp", - "random": "cpp", - "sstream": "cpp", - "stdexcept": "cpp", - "streambuf": "cpp", - "string": "cpp", - "system_error": "cpp", - "tuple": "cpp", - "type_traits": "cpp", - "typeinfo": "cpp", - "utility": "cpp", - "xfacet": "cpp", - "xiosbase": "cpp", - "xlocale": "cpp", - "xlocbuf": "cpp", - "xlocinfo": "cpp", - "xlocmes": "cpp", - "xlocmon": "cpp", - "xlocnum": "cpp", - "xloctime": "cpp", - "xmemory": "cpp", - "xtr1common": "cpp", - "vec_znx_arithmetic_private.h": "c", - "reim4_arithmetic.h": "c", - "array": "c", - "string_view": "c" - }, - "github.copilot.enable": { - "*": false, - "plaintext": false, - "markdown": false, - "scminput": false - } +{ + "cmake.sourceDirectory": "C:/Users/boss_/go/src/github.com/gausslabs/poulpy/backend/spqlios-arithmetic", + "files.associations": { + "vector": "cpp", + "xstring": "cpp", + "xutility": "cpp", + "algorithm": "cpp", + "atomic": "cpp", + "bit": "cpp", + "cctype": "cpp", + "charconv": "cpp", + "cinttypes": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "compare": "cpp", + "complex": "cpp", + "concepts": "cpp", + "cstddef": "cpp", + "cstdint": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cstring": "cpp", + "ctime": "cpp", + "cwchar": "cpp", + "exception": "cpp", + "format": "cpp", + "initializer_list": "cpp", + "ios": "cpp", + "iosfwd": "cpp", + "iostream": "cpp", + "istream": "cpp", + "iterator": "cpp", + "limits": "cpp", + "locale": "cpp", + "memory": "cpp", + "new": "cpp", + "optional": "cpp", + "ostream": "cpp", + "random": "cpp", + "sstream": "cpp", + "stdexcept": "cpp", + "streambuf": "cpp", + "string": "cpp", + "system_error": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "typeinfo": "cpp", + "utility": "cpp", + "xfacet": "cpp", + "xiosbase": "cpp", + "xlocale": "cpp", + "xlocbuf": "cpp", + "xlocinfo": "cpp", + "xlocmes": "cpp", + "xlocmon": "cpp", + "xlocnum": "cpp", + "xloctime": "cpp", + "xmemory": "cpp", + "xtr1common": "cpp", + "vec_znx_arithmetic_private.h": "c", + "reim4_arithmetic.h": "c", + "array": "c", + "string_view": "c" + }, + "github.copilot.enable": { + "*": false, + "plaintext": false, + "markdown": false, + "scminput": false + } } \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock index b9225bf..1b4ded4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -36,7 +36,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7b7e4c2464d97fe331d41de9d5db0def0a96f4d823b8b32a2efd503578988973" [[package]] -name = "base2k" +name = "backend" version = "0.1.0" dependencies = [ "criterion", @@ -131,6 +131,18 @@ version = "0.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6" +[[package]] +name = "core" +version = "0.1.0" +dependencies = [ + "backend", + "criterion", + "itertools 0.14.0", + "rand_distr", + "rug", + "sampling", +] + [[package]] name = "criterion" version = "0.5.1" @@ -488,18 +500,6 @@ version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" -[[package]] -name = "rlwe" -version = "0.1.0" -dependencies = [ - "base2k", - "criterion", - "itertools 0.14.0", - "rand_distr", - "rug", - "sampling", -] - [[package]] name = "rug" version = "1.27.0" diff --git a/Cargo.toml b/Cargo.toml index 6f2a91e..dd3a518 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ [workspace] -members = ["base2k", "core", "sampling", "utils"] +members = ["backend", "core", "sampling", "utils"] resolver = "3" [workspace.dependencies] diff --git a/base2k/.vscode/settings.json b/backend/.vscode/settings.json similarity index 95% rename from base2k/.vscode/settings.json rename to backend/.vscode/settings.json index c38916e..cfbd8eb 100644 --- a/base2k/.vscode/settings.json +++ b/backend/.vscode/settings.json @@ -1,11 +1,11 @@ -{ - "github.copilot.enable": { - "*": false, - "plaintext": false, - "markdown": false, - "scminput": false - }, - "files.associations": { - "random": "c" - } +{ + "github.copilot.enable": { + "*": false, + "plaintext": false, + "markdown": false, + "scminput": false + }, + "files.associations": { + "random": "c" + } } \ No newline at end of file diff --git a/base2k/Cargo.toml b/backend/Cargo.toml similarity index 90% rename from base2k/Cargo.toml rename to backend/Cargo.toml index 089cbde..d0ca857 100644 --- a/base2k/Cargo.toml +++ b/backend/Cargo.toml @@ -1,18 +1,18 @@ -[package] -name = "base2k" -version = "0.1.0" -edition = "2024" - -[dependencies] -rug = {workspace = true} -criterion = {workspace = true} -itertools = {workspace = true} -rand = {workspace = true} -rand_distr = {workspace = true} -rand_core = {workspace = true} -sampling = { path = "../sampling" } -utils = { path = "../utils" } - -[[bench]] -name = "fft" +[package] +name = "backend" +version = "0.1.0" +edition = "2024" + +[dependencies] +rug = {workspace = true} +criterion = {workspace = true} +itertools = {workspace = true} +rand = {workspace = true} +rand_distr = {workspace = true} +rand_core = {workspace = true} +sampling = { path = "../sampling" } +utils = { path = "../utils" } + +[[bench]] +name = "fft" harness = false \ No newline at end of file diff --git a/base2k/README.md b/backend/README.md similarity index 89% rename from base2k/README.md rename to backend/README.md index 08a49e9..86c8c65 100644 --- a/base2k/README.md +++ b/backend/README.md @@ -1,12 +1,12 @@ - -## WSL/Ubuntu -To use this crate you need to build spqlios-arithmetic, which is provided a as a git submodule: -1) Initialize the sub-module -2) $ cd base2k/spqlios-arithmetic -3) mdkir build -4) cd build -5) cmake .. -6) make - -## Others + +## WSL/Ubuntu +To use this crate you need to build spqlios-arithmetic, which is provided a as a git submodule: +1) Initialize the sub-module +2) $ cd backend/spqlios-arithmetic +3) mdkir build +4) cd build +5) cmake .. +6) make + +## Others Steps 3 to 6 might change depending of your platform. See [spqlios-arithmetic/wiki/build](https://github.com/tfhe/spqlios-arithmetic/wiki/build) for additional information and build options. \ No newline at end of file diff --git a/base2k/benches/fft.rs b/backend/benches/fft.rs similarity index 96% rename from base2k/benches/fft.rs rename to backend/benches/fft.rs index a02dc4c..8106a2d 100644 --- a/base2k/benches/fft.rs +++ b/backend/benches/fft.rs @@ -1,56 +1,56 @@ -use base2k::ffi::reim::*; -use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main}; -use std::ffi::c_void; - -fn fft(c: &mut Criterion) { - fn forward<'a>(m: u32, log_bound: u32, reim_fft_precomp: *mut reim_fft_precomp, a: &'a [i64]) -> Box { - unsafe { - let buf_a: *mut f64 = reim_fft_precomp_get_buffer(reim_fft_precomp, 0); - reim_from_znx64_simple(m as u32, log_bound as u32, buf_a as *mut c_void, a.as_ptr()); - Box::new(move || reim_fft(reim_fft_precomp, buf_a)) - } - } - - fn backward<'a>(m: u32, log_bound: u32, reim_ifft_precomp: *mut reim_ifft_precomp, a: &'a [i64]) -> Box { - Box::new(move || unsafe { - let buf_a: *mut f64 = reim_ifft_precomp_get_buffer(reim_ifft_precomp, 0); - reim_from_znx64_simple(m as u32, log_bound as u32, buf_a as *mut c_void, a.as_ptr()); - reim_ifft(reim_ifft_precomp, buf_a); - }) - } - - let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("fft"); - - for log_n in 10..17 { - let n: usize = 1 << log_n; - let m: usize = n >> 1; - let log_bound: u32 = 19; - - let mut a: Vec = vec![i64::default(); n]; - a.iter_mut().enumerate().for_each(|(i, x)| *x = i as i64); - - unsafe { - let reim_fft_precomp: *mut reim_fft_precomp = new_reim_fft_precomp(m as u32, 1); - let reim_ifft_precomp: *mut reim_ifft_precomp = new_reim_ifft_precomp(m as u32, 1); - - let runners: [(String, Box); 2] = [ - (format!("forward"), { - forward(m as u32, log_bound, reim_fft_precomp, &a) - }), - (format!("backward"), { - backward(m as u32, log_bound, reim_ifft_precomp, &a) - }), - ]; - - for (name, mut runner) in runners { - let id: BenchmarkId = BenchmarkId::new(name, format!("n={}", 1 << log_n)); - b.bench_with_input(id, &(), |b: &mut criterion::Bencher<'_>, _| { - b.iter(&mut runner) - }); - } - } - } -} - -criterion_group!(benches, fft,); -criterion_main!(benches); +use backend::ffi::reim::*; +use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main}; +use std::ffi::c_void; + +fn fft(c: &mut Criterion) { + fn forward<'a>(m: u32, log_bound: u32, reim_fft_precomp: *mut reim_fft_precomp, a: &'a [i64]) -> Box { + unsafe { + let buf_a: *mut f64 = reim_fft_precomp_get_buffer(reim_fft_precomp, 0); + reim_from_znx64_simple(m as u32, log_bound as u32, buf_a as *mut c_void, a.as_ptr()); + Box::new(move || reim_fft(reim_fft_precomp, buf_a)) + } + } + + fn backward<'a>(m: u32, log_bound: u32, reim_ifft_precomp: *mut reim_ifft_precomp, a: &'a [i64]) -> Box { + Box::new(move || unsafe { + let buf_a: *mut f64 = reim_ifft_precomp_get_buffer(reim_ifft_precomp, 0); + reim_from_znx64_simple(m as u32, log_bound as u32, buf_a as *mut c_void, a.as_ptr()); + reim_ifft(reim_ifft_precomp, buf_a); + }) + } + + let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("fft"); + + for log_n in 10..17 { + let n: usize = 1 << log_n; + let m: usize = n >> 1; + let log_bound: u32 = 19; + + let mut a: Vec = vec![i64::default(); n]; + a.iter_mut().enumerate().for_each(|(i, x)| *x = i as i64); + + unsafe { + let reim_fft_precomp: *mut reim_fft_precomp = new_reim_fft_precomp(m as u32, 1); + let reim_ifft_precomp: *mut reim_ifft_precomp = new_reim_ifft_precomp(m as u32, 1); + + let runners: [(String, Box); 2] = [ + (format!("forward"), { + forward(m as u32, log_bound, reim_fft_precomp, &a) + }), + (format!("backward"), { + backward(m as u32, log_bound, reim_ifft_precomp, &a) + }), + ]; + + for (name, mut runner) in runners { + let id: BenchmarkId = BenchmarkId::new(name, format!("n={}", 1 << log_n)); + b.bench_with_input(id, &(), |b: &mut criterion::Bencher<'_>, _| { + b.iter(&mut runner) + }); + } + } + } +} + +criterion_group!(benches, fft,); +criterion_main!(benches); diff --git a/base2k/build.rs b/backend/build.rs similarity index 96% rename from base2k/build.rs rename to backend/build.rs index f592b15..93e4098 100644 --- a/base2k/build.rs +++ b/backend/build.rs @@ -1,13 +1,13 @@ -use std::path::absolute; - -fn main() { - println!( - "cargo:rustc-link-search=native={}", - absolute("spqlios-arithmetic/build/spqlios") - .unwrap() - .to_str() - .unwrap() - ); - println!("cargo:rustc-link-lib=static=spqlios"); - // println!("cargo:rustc-link-lib=dylib=spqlios") -} +use std::path::absolute; + +fn main() { + println!( + "cargo:rustc-link-search=native={}", + absolute("spqlios-arithmetic/build/spqlios") + .unwrap() + .to_str() + .unwrap() + ); + println!("cargo:rustc-link-lib=static=spqlios"); + // println!("cargo:rustc-link-lib=dylib=spqlios") +} diff --git a/base2k/examples/fft.rs b/backend/examples/fft.rs similarity index 95% rename from base2k/examples/fft.rs rename to backend/examples/fft.rs index 181d066..63e243c 100644 --- a/base2k/examples/fft.rs +++ b/backend/examples/fft.rs @@ -1,56 +1,56 @@ -use base2k::ffi::reim::*; -use std::ffi::c_void; -use std::time::Instant; - -fn main() { - let log_bound: usize = 19; - - let n: usize = 2048; - let m: usize = n >> 1; - - let mut a: Vec = vec![i64::default(); n]; - let mut b: Vec = vec![i64::default(); n]; - let mut c: Vec = vec![i64::default(); n]; - - a.iter_mut().enumerate().for_each(|(i, x)| *x = i as i64); - b[1] = 1; - - println!("{:?}", b); - - unsafe { - let reim_fft_precomp = new_reim_fft_precomp(m as u32, 2); - let reim_ifft_precomp = new_reim_ifft_precomp(m as u32, 1); - - let buf_a = reim_fft_precomp_get_buffer(reim_fft_precomp, 0); - let buf_b = reim_fft_precomp_get_buffer(reim_fft_precomp, 1); - let buf_c = reim_ifft_precomp_get_buffer(reim_ifft_precomp, 0); - - let now = Instant::now(); - (0..1024).for_each(|_| { - reim_from_znx64_simple(m as u32, log_bound as u32, buf_a as *mut c_void, a.as_ptr()); - reim_fft(reim_fft_precomp, buf_a); - - reim_from_znx64_simple(m as u32, log_bound as u32, buf_b as *mut c_void, b.as_ptr()); - reim_fft(reim_fft_precomp, buf_b); - - reim_fftvec_mul_simple( - m as u32, - buf_c as *mut c_void, - buf_a as *mut c_void, - buf_b as *mut c_void, - ); - reim_ifft(reim_ifft_precomp, buf_c); - - reim_to_znx64_simple( - m as u32, - m as f64, - log_bound as u32, - c.as_mut_ptr(), - buf_c as *mut c_void, - ) - }); - - println!("time: {}us", now.elapsed().as_micros()); - println!("{:?}", &c[..16]); - } -} +use backend::ffi::reim::*; +use std::ffi::c_void; +use std::time::Instant; + +fn main() { + let log_bound: usize = 19; + + let n: usize = 2048; + let m: usize = n >> 1; + + let mut a: Vec = vec![i64::default(); n]; + let mut b: Vec = vec![i64::default(); n]; + let mut c: Vec = vec![i64::default(); n]; + + a.iter_mut().enumerate().for_each(|(i, x)| *x = i as i64); + b[1] = 1; + + println!("{:?}", b); + + unsafe { + let reim_fft_precomp = new_reim_fft_precomp(m as u32, 2); + let reim_ifft_precomp = new_reim_ifft_precomp(m as u32, 1); + + let buf_a = reim_fft_precomp_get_buffer(reim_fft_precomp, 0); + let buf_b = reim_fft_precomp_get_buffer(reim_fft_precomp, 1); + let buf_c = reim_ifft_precomp_get_buffer(reim_ifft_precomp, 0); + + let now = Instant::now(); + (0..1024).for_each(|_| { + reim_from_znx64_simple(m as u32, log_bound as u32, buf_a as *mut c_void, a.as_ptr()); + reim_fft(reim_fft_precomp, buf_a); + + reim_from_znx64_simple(m as u32, log_bound as u32, buf_b as *mut c_void, b.as_ptr()); + reim_fft(reim_fft_precomp, buf_b); + + reim_fftvec_mul_simple( + m as u32, + buf_c as *mut c_void, + buf_a as *mut c_void, + buf_b as *mut c_void, + ); + reim_ifft(reim_ifft_precomp, buf_c); + + reim_to_znx64_simple( + m as u32, + m as f64, + log_bound as u32, + c.as_mut_ptr(), + buf_c as *mut c_void, + ) + }); + + println!("time: {}us", now.elapsed().as_micros()); + println!("{:?}", &c[..16]); + } +} diff --git a/base2k/examples/rlwe_encrypt.rs b/backend/examples/rlwe_encrypt.rs similarity index 85% rename from base2k/examples/rlwe_encrypt.rs rename to backend/examples/rlwe_encrypt.rs index e73db89..a16437f 100644 --- a/base2k/examples/rlwe_encrypt.rs +++ b/backend/examples/rlwe_encrypt.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ AddNormal, Decoding, Encoding, FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScratchOwned, VecZnx, VecZnxAlloc, VecZnxBig, VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxOps, ZnxInfos, @@ -8,10 +8,10 @@ use sampling::source::Source; fn main() { let n: usize = 16; - let log_base2k: usize = 18; + let basek: usize = 18; let ct_size: usize = 3; let msg_size: usize = 2; - let log_scale: usize = msg_size * log_base2k - 5; + let log_scale: usize = msg_size * basek - 5; let module: Module = Module::::new(n); let mut scratch: ScratchOwned = ScratchOwned::new(module.vec_znx_big_normalize_tmp_bytes()); @@ -36,7 +36,7 @@ fn main() { ); // Fill the second column with random values: ct = (0, a) - ct.fill_uniform(log_base2k, 1, ct_size, &mut source); + ct.fill_uniform(basek, 1, ct_size, &mut source); let mut buf_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct_size); @@ -64,8 +64,8 @@ fn main() { let mut want: Vec = vec![0; n]; want.iter_mut() .for_each(|x| *x = source.next_u64n(16, 15) as i64); - m.encode_vec_i64(0, log_base2k, log_scale, &want, 4); - module.vec_znx_normalize_inplace(log_base2k, &mut m, 0, scratch.borrow()); + m.encode_vec_i64(0, basek, log_scale, &want, 4); + module.vec_znx_normalize_inplace(basek, &mut m, 0, scratch.borrow()); // m - BIG(ct[1] * s) module.vec_znx_big_sub_small_b_inplace( @@ -78,7 +78,7 @@ fn main() { // Normalizes back to VecZnx // ct[0] <- m - BIG(c1 * s) module.vec_znx_big_normalize( - log_base2k, + basek, &mut ct, 0, // Selects the first column of ct (ct[0]) &buf_big, @@ -89,9 +89,9 @@ fn main() { // Add noise to ct[0] // ct[0] <- ct[0] + e ct.add_normal( - log_base2k, + basek, 0, // Selects the first column of ct (ct[0]) - log_base2k * ct_size, // Scaling of the noise: 2^{-log_base2k * limbs} + basek * ct_size, // Scaling of the noise: 2^{-basek * limbs} &mut source, 3.2, // Standard deviation 19.0, // Truncatation bound @@ -118,13 +118,13 @@ fn main() { // m + e <- BIG(ct[1] * s + ct[0]) let mut res = module.new_vec_znx(1, ct_size); - module.vec_znx_big_normalize(log_base2k, &mut res, 0, &buf_big, 0, scratch.borrow()); + module.vec_znx_big_normalize(basek, &mut res, 0, &buf_big, 0, scratch.borrow()); // have = m * 2^{log_scale} + e let mut have: Vec = vec![i64::default(); n]; - res.decode_vec_i64(0, log_base2k, res.size() * log_base2k, &mut have); + res.decode_vec_i64(0, basek, res.size() * basek, &mut have); - let scale: f64 = (1 << (res.size() * log_base2k - log_scale)) as f64; + let scale: f64 = (1 << (res.size() * basek - log_scale)) as f64; izip!(want.iter(), have.iter()) .enumerate() .for_each(|(i, (a, b))| { diff --git a/base2k/spqlios-arithmetic b/backend/spqlios-arithmetic similarity index 100% rename from base2k/spqlios-arithmetic rename to backend/spqlios-arithmetic diff --git a/base2k/src/encoding.rs b/backend/src/encoding.rs similarity index 59% rename from base2k/src/encoding.rs rename to backend/src/encoding.rs index 45214c6..dc423f9 100644 --- a/base2k/src/encoding.rs +++ b/backend/src/encoding.rs @@ -11,23 +11,23 @@ pub trait Encoding { /// # Arguments /// /// * `col_i`: the index of the poly where to encode the data. - /// * `log_base2k`: base two negative logarithm decomposition of the receiver. - /// * `log_k`: base two negative logarithm of the scaling of the data. + /// * `basek`: base two negative logarithm decomposition of the receiver. + /// * `k`: base two negative logarithm of the scaling of the data. /// * `data`: data to encode on the receiver. /// * `log_max`: base two logarithm of the infinity norm of the input data. - fn encode_vec_i64(&mut self, col_i: usize, log_base2k: usize, log_k: usize, data: &[i64], log_max: usize); + fn encode_vec_i64(&mut self, col_i: usize, basek: usize, k: usize, data: &[i64], log_max: usize); /// encodes a single i64 on the receiver at the given index. /// /// # Arguments /// /// * `col_i`: the index of the poly where to encode the data. - /// * `log_base2k`: base two negative logarithm decomposition of the receiver. - /// * `log_k`: base two negative logarithm of the scaling of the data. + /// * `basek`: base two negative logarithm decomposition of the receiver. + /// * `k`: base two negative logarithm of the scaling of the data. /// * `i`: index of the coefficient on which to encode the data. /// * `data`: data to encode on the receiver. /// * `log_max`: base two logarithm of the infinity norm of the input data. - fn encode_coeff_i64(&mut self, col_i: usize, log_base2k: usize, log_k: usize, i: usize, data: i64, log_max: usize); + fn encode_coeff_i64(&mut self, col_i: usize, basek: usize, k: usize, i: usize, data: i64, log_max: usize); } pub trait Decoding { @@ -36,70 +36,70 @@ pub trait Decoding { /// # Arguments /// /// * `col_i`: the index of the poly where to encode the data. - /// * `log_base2k`: base two negative logarithm decomposition of the receiver. - /// * `log_k`: base two logarithm of the scaling of the data. + /// * `basek`: base two negative logarithm decomposition of the receiver. + /// * `k`: base two logarithm of the scaling of the data. /// * `data`: data to decode from the receiver. - fn decode_vec_i64(&self, col_i: usize, log_base2k: usize, log_k: usize, data: &mut [i64]); + fn decode_vec_i64(&self, col_i: usize, basek: usize, k: usize, data: &mut [i64]); /// decode a vector of Float from the receiver. /// /// # Arguments /// * `col_i`: the index of the poly where to encode the data. - /// * `log_base2k`: base two negative logarithm decomposition of the receiver. + /// * `basek`: base two negative logarithm decomposition of the receiver. /// * `data`: data to decode from the receiver. - fn decode_vec_float(&self, col_i: usize, log_base2k: usize, data: &mut [Float]); + fn decode_vec_float(&self, col_i: usize, basek: usize, data: &mut [Float]); /// decode a single of i64 from the receiver at the given index. /// /// # Arguments /// /// * `col_i`: the index of the poly where to encode the data. - /// * `log_base2k`: base two negative logarithm decomposition of the receiver. - /// * `log_k`: base two negative logarithm of the scaling of the data. + /// * `basek`: base two negative logarithm decomposition of the receiver. + /// * `k`: base two negative logarithm of the scaling of the data. /// * `i`: index of the coefficient to decode. /// * `data`: data to decode from the receiver. - fn decode_coeff_i64(&self, col_i: usize, log_base2k: usize, log_k: usize, i: usize) -> i64; + fn decode_coeff_i64(&self, col_i: usize, basek: usize, k: usize, i: usize) -> i64; } impl + AsRef<[u8]>> Encoding for VecZnx { - fn encode_vec_i64(&mut self, col_i: usize, log_base2k: usize, log_k: usize, data: &[i64], log_max: usize) { - encode_vec_i64(self, col_i, log_base2k, log_k, data, log_max) + fn encode_vec_i64(&mut self, col_i: usize, basek: usize, k: usize, data: &[i64], log_max: usize) { + encode_vec_i64(self, col_i, basek, k, data, log_max) } - fn encode_coeff_i64(&mut self, col_i: usize, log_base2k: usize, log_k: usize, i: usize, value: i64, log_max: usize) { - encode_coeff_i64(self, col_i, log_base2k, log_k, i, value, log_max) + fn encode_coeff_i64(&mut self, col_i: usize, basek: usize, k: usize, i: usize, value: i64, log_max: usize) { + encode_coeff_i64(self, col_i, basek, k, i, value, log_max) } } impl> Decoding for VecZnx { - fn decode_vec_i64(&self, col_i: usize, log_base2k: usize, log_k: usize, data: &mut [i64]) { - decode_vec_i64(self, col_i, log_base2k, log_k, data) + fn decode_vec_i64(&self, col_i: usize, basek: usize, k: usize, data: &mut [i64]) { + decode_vec_i64(self, col_i, basek, k, data) } - fn decode_vec_float(&self, col_i: usize, log_base2k: usize, data: &mut [Float]) { - decode_vec_float(self, col_i, log_base2k, data) + fn decode_vec_float(&self, col_i: usize, basek: usize, data: &mut [Float]) { + decode_vec_float(self, col_i, basek, data) } - fn decode_coeff_i64(&self, col_i: usize, log_base2k: usize, log_k: usize, i: usize) -> i64 { - decode_coeff_i64(self, col_i, log_base2k, log_k, i) + fn decode_coeff_i64(&self, col_i: usize, basek: usize, k: usize, i: usize) -> i64 { + decode_coeff_i64(self, col_i, basek, k, i) } } fn encode_vec_i64 + AsRef<[u8]>>( a: &mut VecZnx, col_i: usize, - log_base2k: usize, - log_k: usize, + basek: usize, + k: usize, data: &[i64], log_max: usize, ) { - let size: usize = (log_k + log_base2k - 1) / log_base2k; + let size: usize = (k + basek - 1) / basek; #[cfg(debug_assertions)] { assert!( size <= a.size(), - "invalid argument log_k: (log_k + a.log_base2k - 1)/a.log_base2k={} > a.size()={}", + "invalid argument k: (k + a.basek - 1)/a.basek={} > a.size()={}", size, a.size() ); @@ -108,43 +108,43 @@ fn encode_vec_i64 + AsRef<[u8]>>( } let data_len: usize = data.len(); - let log_k_rem: usize = log_base2k - (log_k % log_base2k); + let k_rem: usize = basek - (k % basek); // Zeroes coefficients of the i-th column (0..a.size()).for_each(|i| unsafe { znx_zero_i64_ref(a.n() as u64, a.at_mut_ptr(col_i, i)); }); - // If 2^{log_base2k} * 2^{k_rem} < 2^{63}-1, then we can simply copy + // If 2^{basek} * 2^{k_rem} < 2^{63}-1, then we can simply copy // values on the last limb. // Else we decompose values base2k. - if log_max + log_k_rem < 63 || log_k_rem == log_base2k { + if log_max + k_rem < 63 || k_rem == basek { a.at_mut(col_i, size - 1)[..data_len].copy_from_slice(&data[..data_len]); } else { - let mask: i64 = (1 << log_base2k) - 1; - let steps: usize = min(size, (log_max + log_base2k - 1) / log_base2k); + let mask: i64 = (1 << basek) - 1; + let steps: usize = min(size, (log_max + basek - 1) / basek); (size - steps..size) .rev() .enumerate() .for_each(|(i, i_rev)| { - let shift: usize = i * log_base2k; + let shift: usize = i * basek; izip!(a.at_mut(col_i, i_rev).iter_mut(), data.iter()).for_each(|(y, x)| *y = (x >> shift) & mask); }) } // Case where self.prec % self.k != 0. - if log_k_rem != log_base2k { - let steps: usize = min(size, (log_max + log_base2k - 1) / log_base2k); + if k_rem != basek { + let steps: usize = min(size, (log_max + basek - 1) / basek); (size - steps..size).rev().for_each(|i| { a.at_mut(col_i, i)[..data_len] .iter_mut() - .for_each(|x| *x <<= log_k_rem); + .for_each(|x| *x <<= k_rem); }) } } -fn decode_vec_i64>(a: &VecZnx, col_i: usize, log_base2k: usize, log_k: usize, data: &mut [i64]) { - let size: usize = (log_k + log_base2k - 1) / log_base2k; +fn decode_vec_i64>(a: &VecZnx, col_i: usize, basek: usize, k: usize, data: &mut [i64]) { + let size: usize = (k + basek - 1) / basek; #[cfg(debug_assertions)] { assert!( @@ -156,22 +156,22 @@ fn decode_vec_i64>(a: &VecZnx, col_i: usize, log_base2k: usize assert!(col_i < a.cols()); } data.copy_from_slice(a.at(col_i, 0)); - let rem: usize = log_base2k - (log_k % log_base2k); + let rem: usize = basek - (k % basek); (1..size).for_each(|i| { - if i == size - 1 && rem != log_base2k { - let k_rem: usize = log_base2k - rem; + if i == size - 1 && rem != basek { + let k_rem: usize = basek - rem; izip!(a.at(col_i, i).iter(), data.iter_mut()).for_each(|(x, y)| { *y = (*y << k_rem) + (x >> rem); }); } else { izip!(a.at(col_i, i).iter(), data.iter_mut()).for_each(|(x, y)| { - *y = (*y << log_base2k) + x; + *y = (*y << basek) + x; }); } }) } -fn decode_vec_float>(a: &VecZnx, col_i: usize, log_base2k: usize, data: &mut [Float]) { +fn decode_vec_float>(a: &VecZnx, col_i: usize, basek: usize, data: &mut [Float]) { let size: usize = a.size(); #[cfg(debug_assertions)] { @@ -184,12 +184,12 @@ fn decode_vec_float>(a: &VecZnx, col_i: usize, log_base2k: usi assert!(col_i < a.cols()); } - let prec: u32 = (log_base2k * size) as u32; + let prec: u32 = (basek * size) as u32; - // 2^{log_base2k} - let base = Float::with_val(prec, (1 << log_base2k) as f64); + // 2^{basek} + let base = Float::with_val(prec, (1 << basek) as f64); - // y[i] = sum x[j][i] * 2^{-log_base2k*j} + // y[i] = sum x[j][i] * 2^{-basek*j} (0..size).for_each(|i| { if i == 0 { izip!(a.at(col_i, size - i - 1).iter(), data.iter_mut()).for_each(|(x, y)| { @@ -208,73 +208,73 @@ fn decode_vec_float>(a: &VecZnx, col_i: usize, log_base2k: usi fn encode_coeff_i64 + AsRef<[u8]>>( a: &mut VecZnx, col_i: usize, - log_base2k: usize, - log_k: usize, + basek: usize, + k: usize, i: usize, value: i64, log_max: usize, ) { - let size: usize = (log_k + log_base2k - 1) / log_base2k; + let size: usize = (k + basek - 1) / basek; #[cfg(debug_assertions)] { assert!(i < a.n()); assert!( size <= a.size(), - "invalid argument log_k: (log_k + a.log_base2k - 1)/a.log_base2k={} > a.size()={}", + "invalid argument k: (k + a.basek - 1)/a.basek={} > a.size()={}", size, a.size() ); assert!(col_i < a.cols()); } - let log_k_rem: usize = log_base2k - (log_k % log_base2k); + let k_rem: usize = basek - (k % basek); (0..a.size()).for_each(|j| a.at_mut(col_i, j)[i] = 0); - // If 2^{log_base2k} * 2^{log_k_rem} < 2^{63}-1, then we can simply copy + // If 2^{basek} * 2^{k_rem} < 2^{63}-1, then we can simply copy // values on the last limb. // Else we decompose values base2k. - if log_max + log_k_rem < 63 || log_k_rem == log_base2k { + if log_max + k_rem < 63 || k_rem == basek { a.at_mut(col_i, size - 1)[i] = value; } else { - let mask: i64 = (1 << log_base2k) - 1; - let steps: usize = min(size, (log_max + log_base2k - 1) / log_base2k); + let mask: i64 = (1 << basek) - 1; + let steps: usize = min(size, (log_max + basek - 1) / basek); (size - steps..size) .rev() .enumerate() .for_each(|(j, j_rev)| { - a.at_mut(col_i, j_rev)[i] = (value >> (j * log_base2k)) & mask; + a.at_mut(col_i, j_rev)[i] = (value >> (j * basek)) & mask; }) } // Case where prec % k != 0. - if log_k_rem != log_base2k { - let steps: usize = min(size, (log_max + log_base2k - 1) / log_base2k); + if k_rem != basek { + let steps: usize = min(size, (log_max + basek - 1) / basek); (size - steps..size).rev().for_each(|j| { - a.at_mut(col_i, j)[i] <<= log_k_rem; + a.at_mut(col_i, j)[i] <<= k_rem; }) } } -fn decode_coeff_i64>(a: &VecZnx, col_i: usize, log_base2k: usize, log_k: usize, i: usize) -> i64 { +fn decode_coeff_i64>(a: &VecZnx, col_i: usize, basek: usize, k: usize, i: usize) -> i64 { #[cfg(debug_assertions)] { assert!(i < a.n()); assert!(col_i < a.cols()) } - let cols: usize = (log_k + log_base2k - 1) / log_base2k; + let cols: usize = (k + basek - 1) / basek; let data: &[i64] = a.raw(); let mut res: i64 = data[i]; - let rem: usize = log_base2k - (log_k % log_base2k); + let rem: usize = basek - (k % basek); let slice_size: usize = a.n() * a.size(); (1..cols).for_each(|i| { let x = data[i * slice_size]; - if i == cols - 1 && rem != log_base2k { - let k_rem: usize = log_base2k - rem; + if i == cols - 1 && rem != basek { + let k_rem: usize = basek - rem; res = (res << k_rem) + (x >> rem); } else { - res = (res << log_base2k) + x; + res = (res << basek) + x; } }); res @@ -292,9 +292,9 @@ mod tests { fn test_set_get_i64_lo_norm() { let n: usize = 8; let module: Module = Module::::new(n); - let log_base2k: usize = 17; + let basek: usize = 17; let size: usize = 5; - let log_k: usize = size * log_base2k - 5; + let k: usize = size * basek - 5; let mut a: VecZnx<_> = module.new_vec_znx(2, size); let mut source: Source = Source::new([0u8; 32]); let raw: &mut [i64] = a.raw_mut(); @@ -303,9 +303,9 @@ mod tests { let mut have: Vec = vec![i64::default(); n]; have.iter_mut() .for_each(|x| *x = (source.next_i64() << 56) >> 56); - a.encode_vec_i64(col_i, log_base2k, log_k, &have, 10); + a.encode_vec_i64(col_i, basek, k, &have, 10); let mut want: Vec = vec![i64::default(); n]; - a.decode_vec_i64(col_i, log_base2k, log_k, &mut want); + a.decode_vec_i64(col_i, basek, k, &mut want); izip!(want, have).for_each(|(a, b)| assert_eq!(a, b, "{} != {}", a, b)); }); } @@ -314,9 +314,9 @@ mod tests { fn test_set_get_i64_hi_norm() { let n: usize = 8; let module: Module = Module::::new(n); - let log_base2k: usize = 17; + let basek: usize = 17; let size: usize = 5; - let log_k: usize = size * log_base2k - 5; + let k: usize = size * basek - 5; let mut a: VecZnx<_> = module.new_vec_znx(2, size); let mut source = Source::new([0u8; 32]); let raw: &mut [i64] = a.raw_mut(); @@ -324,9 +324,9 @@ mod tests { (0..a.cols()).for_each(|col_i| { let mut have: Vec = vec![i64::default(); n]; have.iter_mut().for_each(|x| *x = source.next_i64()); - a.encode_vec_i64(col_i, log_base2k, log_k, &have, 64); + a.encode_vec_i64(col_i, basek, k, &have, 64); let mut want = vec![i64::default(); n]; - a.decode_vec_i64(col_i, log_base2k, log_k, &mut want); + a.decode_vec_i64(col_i, basek, k, &mut want); izip!(want, have).for_each(|(a, b)| assert_eq!(a, b, "{} != {}", a, b)); }) } diff --git a/base2k/src/ffi/cnv.rs b/backend/src/ffi/cnv.rs similarity index 95% rename from base2k/src/ffi/cnv.rs rename to backend/src/ffi/cnv.rs index be8aae3..07b4f7f 100644 --- a/base2k/src/ffi/cnv.rs +++ b/backend/src/ffi/cnv.rs @@ -1,7 +1,7 @@ -pub type CNV_PVEC_L = cnv_pvec_l_t; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct cnv_pvec_r_t { - _unused: [u8; 0], -} -pub type CNV_PVEC_R = cnv_pvec_r_t; +pub type CNV_PVEC_L = cnv_pvec_l_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cnv_pvec_r_t { + _unused: [u8; 0], +} +pub type CNV_PVEC_R = cnv_pvec_r_t; diff --git a/base2k/src/ffi/mod.rs b/backend/src/ffi/mod.rs similarity index 94% rename from base2k/src/ffi/mod.rs rename to backend/src/ffi/mod.rs index 57e9291..4213310 100644 --- a/base2k/src/ffi/mod.rs +++ b/backend/src/ffi/mod.rs @@ -1,8 +1,8 @@ -pub mod module; -pub mod reim; -pub mod svp; -pub mod vec_znx; -pub mod vec_znx_big; -pub mod vec_znx_dft; -pub mod vmp; -pub mod znx; +pub mod module; +pub mod reim; +pub mod svp; +pub mod vec_znx; +pub mod vec_znx_big; +pub mod vec_znx_dft; +pub mod vmp; +pub mod znx; diff --git a/base2k/src/ffi/module.rs b/backend/src/ffi/module.rs similarity index 96% rename from base2k/src/ffi/module.rs rename to backend/src/ffi/module.rs index e35d4c0..011c419 100644 --- a/base2k/src/ffi/module.rs +++ b/backend/src/ffi/module.rs @@ -1,18 +1,18 @@ -pub struct module_info_t { - _unused: [u8; 0], -} - -pub type module_type_t = ::std::os::raw::c_uint; -pub use self::module_type_t as MODULE_TYPE; - -pub type MODULE = module_info_t; - -unsafe extern "C" { - pub unsafe fn new_module_info(N: u64, mode: MODULE_TYPE) -> *mut MODULE; -} -unsafe extern "C" { - pub unsafe fn delete_module_info(module_info: *mut MODULE); -} -unsafe extern "C" { - pub unsafe fn module_get_n(module: *const MODULE) -> u64; -} +pub struct module_info_t { + _unused: [u8; 0], +} + +pub type module_type_t = ::std::os::raw::c_uint; +pub use self::module_type_t as MODULE_TYPE; + +pub type MODULE = module_info_t; + +unsafe extern "C" { + pub unsafe fn new_module_info(N: u64, mode: MODULE_TYPE) -> *mut MODULE; +} +unsafe extern "C" { + pub unsafe fn delete_module_info(module_info: *mut MODULE); +} +unsafe extern "C" { + pub unsafe fn module_get_n(module: *const MODULE) -> u64; +} diff --git a/base2k/src/ffi/reim.rs b/backend/src/ffi/reim.rs similarity index 97% rename from base2k/src/ffi/reim.rs rename to backend/src/ffi/reim.rs index eb2fae7..a3ce548 100644 --- a/base2k/src/ffi/reim.rs +++ b/backend/src/ffi/reim.rs @@ -1,172 +1,172 @@ -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_fft_precomp { - _unused: [u8; 0], -} -pub type REIM_FFT_PRECOMP = reim_fft_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_ifft_precomp { - _unused: [u8; 0], -} -pub type REIM_IFFT_PRECOMP = reim_ifft_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_mul_precomp { - _unused: [u8; 0], -} -pub type REIM_FFTVEC_MUL_PRECOMP = reim_mul_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_addmul_precomp { - _unused: [u8; 0], -} -pub type REIM_FFTVEC_ADDMUL_PRECOMP = reim_addmul_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_from_znx32_precomp { - _unused: [u8; 0], -} -pub type REIM_FROM_ZNX32_PRECOMP = reim_from_znx32_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_from_znx64_precomp { - _unused: [u8; 0], -} -pub type REIM_FROM_ZNX64_PRECOMP = reim_from_znx64_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_from_tnx32_precomp { - _unused: [u8; 0], -} -pub type REIM_FROM_TNX32_PRECOMP = reim_from_tnx32_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_to_tnx32_precomp { - _unused: [u8; 0], -} -pub type REIM_TO_TNX32_PRECOMP = reim_to_tnx32_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_to_tnx_precomp { - _unused: [u8; 0], -} -pub type REIM_TO_TNX_PRECOMP = reim_to_tnx_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_to_znx64_precomp { - _unused: [u8; 0], -} -pub type REIM_TO_ZNX64_PRECOMP = reim_to_znx64_precomp; -unsafe extern "C" { - pub unsafe fn new_reim_fft_precomp(m: u32, num_buffers: u32) -> *mut REIM_FFT_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_fft_precomp_get_buffer(tables: *const REIM_FFT_PRECOMP, buffer_index: u32) -> *mut f64; -} -unsafe extern "C" { - pub unsafe fn new_reim_fft_buffer(m: u32) -> *mut f64; -} -unsafe extern "C" { - pub unsafe fn delete_reim_fft_buffer(buffer: *mut f64); -} -unsafe extern "C" { - pub unsafe fn reim_fft(tables: *const REIM_FFT_PRECOMP, data: *mut f64); -} -unsafe extern "C" { - pub unsafe fn new_reim_ifft_precomp(m: u32, num_buffers: u32) -> *mut REIM_IFFT_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_ifft_precomp_get_buffer(tables: *const REIM_IFFT_PRECOMP, buffer_index: u32) -> *mut f64; -} -unsafe extern "C" { - pub unsafe fn reim_ifft(tables: *const REIM_IFFT_PRECOMP, data: *mut f64); -} -unsafe extern "C" { - pub unsafe fn new_reim_fftvec_mul_precomp(m: u32) -> *mut REIM_FFTVEC_MUL_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_fftvec_mul(tables: *const REIM_FFTVEC_MUL_PRECOMP, r: *mut f64, a: *const f64, b: *const f64); -} -unsafe extern "C" { - pub unsafe fn new_reim_fftvec_addmul_precomp(m: u32) -> *mut REIM_FFTVEC_ADDMUL_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_fftvec_addmul(tables: *const REIM_FFTVEC_ADDMUL_PRECOMP, r: *mut f64, a: *const f64, b: *const f64); -} -unsafe extern "C" { - pub unsafe fn new_reim_from_znx32_precomp(m: u32, log2bound: u32) -> *mut REIM_FROM_ZNX32_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_from_znx32(tables: *const REIM_FROM_ZNX32_PRECOMP, r: *mut ::std::os::raw::c_void, a: *const i32); -} -unsafe extern "C" { - pub unsafe fn reim_from_znx64(tables: *const REIM_FROM_ZNX64_PRECOMP, r: *mut ::std::os::raw::c_void, a: *const i64); -} -unsafe extern "C" { - pub unsafe fn new_reim_from_znx64_precomp(m: u32, maxbnd: u32) -> *mut REIM_FROM_ZNX64_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_from_znx64_simple(m: u32, log2bound: u32, r: *mut ::std::os::raw::c_void, a: *const i64); -} -unsafe extern "C" { - pub unsafe fn new_reim_from_tnx32_precomp(m: u32) -> *mut REIM_FROM_TNX32_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_from_tnx32(tables: *const REIM_FROM_TNX32_PRECOMP, r: *mut ::std::os::raw::c_void, a: *const i32); -} -unsafe extern "C" { - pub unsafe fn new_reim_to_tnx32_precomp(m: u32, divisor: f64, log2overhead: u32) -> *mut REIM_TO_TNX32_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_to_tnx32(tables: *const REIM_TO_TNX32_PRECOMP, r: *mut i32, a: *const ::std::os::raw::c_void); -} -unsafe extern "C" { - pub unsafe fn new_reim_to_tnx_precomp(m: u32, divisor: f64, log2overhead: u32) -> *mut REIM_TO_TNX_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_to_tnx(tables: *const REIM_TO_TNX_PRECOMP, r: *mut f64, a: *const f64); -} -unsafe extern "C" { - pub unsafe fn reim_to_tnx_simple(m: u32, divisor: f64, log2overhead: u32, r: *mut f64, a: *const f64); -} -unsafe extern "C" { - pub unsafe fn new_reim_to_znx64_precomp(m: u32, divisor: f64, log2bound: u32) -> *mut REIM_TO_ZNX64_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_to_znx64(precomp: *const REIM_TO_ZNX64_PRECOMP, r: *mut i64, a: *const ::std::os::raw::c_void); -} -unsafe extern "C" { - pub unsafe fn reim_to_znx64_simple(m: u32, divisor: f64, log2bound: u32, r: *mut i64, a: *const ::std::os::raw::c_void); -} -unsafe extern "C" { - pub unsafe fn reim_fft_simple(m: u32, data: *mut ::std::os::raw::c_void); -} -unsafe extern "C" { - pub unsafe fn reim_ifft_simple(m: u32, data: *mut ::std::os::raw::c_void); -} -unsafe extern "C" { - pub unsafe fn reim_fftvec_mul_simple( - m: u32, - r: *mut ::std::os::raw::c_void, - a: *const ::std::os::raw::c_void, - b: *const ::std::os::raw::c_void, - ); -} -unsafe extern "C" { - pub unsafe fn reim_fftvec_addmul_simple( - m: u32, - r: *mut ::std::os::raw::c_void, - a: *const ::std::os::raw::c_void, - b: *const ::std::os::raw::c_void, - ); -} -unsafe extern "C" { - pub unsafe fn reim_from_znx32_simple(m: u32, log2bound: u32, r: *mut ::std::os::raw::c_void, x: *const i32); -} -unsafe extern "C" { - pub unsafe fn reim_from_tnx32_simple(m: u32, r: *mut ::std::os::raw::c_void, x: *const i32); -} -unsafe extern "C" { - pub unsafe fn reim_to_tnx32_simple(m: u32, divisor: f64, log2overhead: u32, r: *mut i32, x: *const ::std::os::raw::c_void); -} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_fft_precomp { + _unused: [u8; 0], +} +pub type REIM_FFT_PRECOMP = reim_fft_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_ifft_precomp { + _unused: [u8; 0], +} +pub type REIM_IFFT_PRECOMP = reim_ifft_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_mul_precomp { + _unused: [u8; 0], +} +pub type REIM_FFTVEC_MUL_PRECOMP = reim_mul_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_addmul_precomp { + _unused: [u8; 0], +} +pub type REIM_FFTVEC_ADDMUL_PRECOMP = reim_addmul_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_from_znx32_precomp { + _unused: [u8; 0], +} +pub type REIM_FROM_ZNX32_PRECOMP = reim_from_znx32_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_from_znx64_precomp { + _unused: [u8; 0], +} +pub type REIM_FROM_ZNX64_PRECOMP = reim_from_znx64_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_from_tnx32_precomp { + _unused: [u8; 0], +} +pub type REIM_FROM_TNX32_PRECOMP = reim_from_tnx32_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_to_tnx32_precomp { + _unused: [u8; 0], +} +pub type REIM_TO_TNX32_PRECOMP = reim_to_tnx32_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_to_tnx_precomp { + _unused: [u8; 0], +} +pub type REIM_TO_TNX_PRECOMP = reim_to_tnx_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_to_znx64_precomp { + _unused: [u8; 0], +} +pub type REIM_TO_ZNX64_PRECOMP = reim_to_znx64_precomp; +unsafe extern "C" { + pub unsafe fn new_reim_fft_precomp(m: u32, num_buffers: u32) -> *mut REIM_FFT_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_fft_precomp_get_buffer(tables: *const REIM_FFT_PRECOMP, buffer_index: u32) -> *mut f64; +} +unsafe extern "C" { + pub unsafe fn new_reim_fft_buffer(m: u32) -> *mut f64; +} +unsafe extern "C" { + pub unsafe fn delete_reim_fft_buffer(buffer: *mut f64); +} +unsafe extern "C" { + pub unsafe fn reim_fft(tables: *const REIM_FFT_PRECOMP, data: *mut f64); +} +unsafe extern "C" { + pub unsafe fn new_reim_ifft_precomp(m: u32, num_buffers: u32) -> *mut REIM_IFFT_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_ifft_precomp_get_buffer(tables: *const REIM_IFFT_PRECOMP, buffer_index: u32) -> *mut f64; +} +unsafe extern "C" { + pub unsafe fn reim_ifft(tables: *const REIM_IFFT_PRECOMP, data: *mut f64); +} +unsafe extern "C" { + pub unsafe fn new_reim_fftvec_mul_precomp(m: u32) -> *mut REIM_FFTVEC_MUL_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_fftvec_mul(tables: *const REIM_FFTVEC_MUL_PRECOMP, r: *mut f64, a: *const f64, b: *const f64); +} +unsafe extern "C" { + pub unsafe fn new_reim_fftvec_addmul_precomp(m: u32) -> *mut REIM_FFTVEC_ADDMUL_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_fftvec_addmul(tables: *const REIM_FFTVEC_ADDMUL_PRECOMP, r: *mut f64, a: *const f64, b: *const f64); +} +unsafe extern "C" { + pub unsafe fn new_reim_from_znx32_precomp(m: u32, log2bound: u32) -> *mut REIM_FROM_ZNX32_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_from_znx32(tables: *const REIM_FROM_ZNX32_PRECOMP, r: *mut ::std::os::raw::c_void, a: *const i32); +} +unsafe extern "C" { + pub unsafe fn reim_from_znx64(tables: *const REIM_FROM_ZNX64_PRECOMP, r: *mut ::std::os::raw::c_void, a: *const i64); +} +unsafe extern "C" { + pub unsafe fn new_reim_from_znx64_precomp(m: u32, maxbnd: u32) -> *mut REIM_FROM_ZNX64_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_from_znx64_simple(m: u32, log2bound: u32, r: *mut ::std::os::raw::c_void, a: *const i64); +} +unsafe extern "C" { + pub unsafe fn new_reim_from_tnx32_precomp(m: u32) -> *mut REIM_FROM_TNX32_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_from_tnx32(tables: *const REIM_FROM_TNX32_PRECOMP, r: *mut ::std::os::raw::c_void, a: *const i32); +} +unsafe extern "C" { + pub unsafe fn new_reim_to_tnx32_precomp(m: u32, divisor: f64, log2overhead: u32) -> *mut REIM_TO_TNX32_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_to_tnx32(tables: *const REIM_TO_TNX32_PRECOMP, r: *mut i32, a: *const ::std::os::raw::c_void); +} +unsafe extern "C" { + pub unsafe fn new_reim_to_tnx_precomp(m: u32, divisor: f64, log2overhead: u32) -> *mut REIM_TO_TNX_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_to_tnx(tables: *const REIM_TO_TNX_PRECOMP, r: *mut f64, a: *const f64); +} +unsafe extern "C" { + pub unsafe fn reim_to_tnx_simple(m: u32, divisor: f64, log2overhead: u32, r: *mut f64, a: *const f64); +} +unsafe extern "C" { + pub unsafe fn new_reim_to_znx64_precomp(m: u32, divisor: f64, log2bound: u32) -> *mut REIM_TO_ZNX64_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_to_znx64(precomp: *const REIM_TO_ZNX64_PRECOMP, r: *mut i64, a: *const ::std::os::raw::c_void); +} +unsafe extern "C" { + pub unsafe fn reim_to_znx64_simple(m: u32, divisor: f64, log2bound: u32, r: *mut i64, a: *const ::std::os::raw::c_void); +} +unsafe extern "C" { + pub unsafe fn reim_fft_simple(m: u32, data: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub unsafe fn reim_ifft_simple(m: u32, data: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub unsafe fn reim_fftvec_mul_simple( + m: u32, + r: *mut ::std::os::raw::c_void, + a: *const ::std::os::raw::c_void, + b: *const ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub unsafe fn reim_fftvec_addmul_simple( + m: u32, + r: *mut ::std::os::raw::c_void, + a: *const ::std::os::raw::c_void, + b: *const ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub unsafe fn reim_from_znx32_simple(m: u32, log2bound: u32, r: *mut ::std::os::raw::c_void, x: *const i32); +} +unsafe extern "C" { + pub unsafe fn reim_from_tnx32_simple(m: u32, r: *mut ::std::os::raw::c_void, x: *const i32); +} +unsafe extern "C" { + pub unsafe fn reim_to_tnx32_simple(m: u32, divisor: f64, log2overhead: u32, r: *mut i32, x: *const ::std::os::raw::c_void); +} diff --git a/base2k/src/ffi/svp.rs b/backend/src/ffi/svp.rs similarity index 95% rename from base2k/src/ffi/svp.rs rename to backend/src/ffi/svp.rs index 08b2da1..8c994c9 100644 --- a/base2k/src/ffi/svp.rs +++ b/backend/src/ffi/svp.rs @@ -1,48 +1,48 @@ -use crate::ffi::module::MODULE; -use crate::ffi::vec_znx_dft::VEC_ZNX_DFT; - -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct svp_ppol_t { - _unused: [u8; 0], -} -pub type SVP_PPOL = svp_ppol_t; - -unsafe extern "C" { - pub unsafe fn bytes_of_svp_ppol(module: *const MODULE) -> u64; -} -unsafe extern "C" { - pub unsafe fn new_svp_ppol(module: *const MODULE) -> *mut SVP_PPOL; -} -unsafe extern "C" { - pub unsafe fn delete_svp_ppol(res: *mut SVP_PPOL); -} - -unsafe extern "C" { - pub unsafe fn svp_prepare(module: *const MODULE, ppol: *mut SVP_PPOL, pol: *const i64); -} - -unsafe extern "C" { - pub unsafe fn svp_apply_dft( - module: *const MODULE, - res: *const VEC_ZNX_DFT, - res_size: u64, - ppol: *const SVP_PPOL, - a: *const i64, - a_size: u64, - a_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn svp_apply_dft_to_dft( - module: *const MODULE, - res: *const VEC_ZNX_DFT, - res_size: u64, - res_cols: u64, - ppol: *const SVP_PPOL, - a: *const VEC_ZNX_DFT, - a_size: u64, - a_cols: u64, - ); -} +use crate::ffi::module::MODULE; +use crate::ffi::vec_znx_dft::VEC_ZNX_DFT; + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct svp_ppol_t { + _unused: [u8; 0], +} +pub type SVP_PPOL = svp_ppol_t; + +unsafe extern "C" { + pub unsafe fn bytes_of_svp_ppol(module: *const MODULE) -> u64; +} +unsafe extern "C" { + pub unsafe fn new_svp_ppol(module: *const MODULE) -> *mut SVP_PPOL; +} +unsafe extern "C" { + pub unsafe fn delete_svp_ppol(res: *mut SVP_PPOL); +} + +unsafe extern "C" { + pub unsafe fn svp_prepare(module: *const MODULE, ppol: *mut SVP_PPOL, pol: *const i64); +} + +unsafe extern "C" { + pub unsafe fn svp_apply_dft( + module: *const MODULE, + res: *const VEC_ZNX_DFT, + res_size: u64, + ppol: *const SVP_PPOL, + a: *const i64, + a_size: u64, + a_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn svp_apply_dft_to_dft( + module: *const MODULE, + res: *const VEC_ZNX_DFT, + res_size: u64, + res_cols: u64, + ppol: *const SVP_PPOL, + a: *const VEC_ZNX_DFT, + a_size: u64, + a_cols: u64, + ); +} diff --git a/base2k/src/ffi/vec_znx.rs b/backend/src/ffi/vec_znx.rs similarity index 94% rename from base2k/src/ffi/vec_znx.rs rename to backend/src/ffi/vec_znx.rs index 26dec8c..b377fd1 100644 --- a/base2k/src/ffi/vec_znx.rs +++ b/backend/src/ffi/vec_znx.rs @@ -1,101 +1,101 @@ -use crate::ffi::module::MODULE; - -unsafe extern "C" { - pub unsafe fn vec_znx_add( - module: *const MODULE, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - b: *const i64, - b_size: u64, - b_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_automorphism( - module: *const MODULE, - p: i64, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_negate( - module: *const MODULE, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_rotate( - module: *const MODULE, - p: i64, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_sub( - module: *const MODULE, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - b: *const i64, - b_size: u64, - b_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_zero(module: *const MODULE, res: *mut i64, res_size: u64, res_sl: u64); -} -unsafe extern "C" { - pub unsafe fn vec_znx_copy( - module: *const MODULE, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_normalize_base2k( - module: *const MODULE, - log2_base2k: u64, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - tmp_space: *mut u8, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_normalize_base2k_tmp_bytes(module: *const MODULE) -> u64; -} +use crate::ffi::module::MODULE; + +unsafe extern "C" { + pub unsafe fn vec_znx_add( + module: *const MODULE, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + b: *const i64, + b_size: u64, + b_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_automorphism( + module: *const MODULE, + p: i64, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_negate( + module: *const MODULE, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_rotate( + module: *const MODULE, + p: i64, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_sub( + module: *const MODULE, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + b: *const i64, + b_size: u64, + b_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_zero(module: *const MODULE, res: *mut i64, res_size: u64, res_sl: u64); +} +unsafe extern "C" { + pub unsafe fn vec_znx_copy( + module: *const MODULE, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_normalize_base2k( + module: *const MODULE, + base2k: u64, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + tmp_space: *mut u8, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_normalize_base2k_tmp_bytes(module: *const MODULE) -> u64; +} diff --git a/base2k/src/ffi/vec_znx_big.rs b/backend/src/ffi/vec_znx_big.rs similarity index 95% rename from base2k/src/ffi/vec_znx_big.rs rename to backend/src/ffi/vec_znx_big.rs index 8c06e90..1353051 100644 --- a/base2k/src/ffi/vec_znx_big.rs +++ b/backend/src/ffi/vec_znx_big.rs @@ -1,161 +1,161 @@ -use crate::ffi::module::MODULE; - -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct vec_znx_big_t { - _unused: [u8; 0], -} -pub type VEC_ZNX_BIG = vec_znx_big_t; - -unsafe extern "C" { - pub unsafe fn bytes_of_vec_znx_big(module: *const MODULE, size: u64) -> u64; -} -unsafe extern "C" { - pub unsafe fn new_vec_znx_big(module: *const MODULE, size: u64) -> *mut VEC_ZNX_BIG; -} -unsafe extern "C" { - pub unsafe fn delete_vec_znx_big(res: *mut VEC_ZNX_BIG); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_add( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - b: *const VEC_ZNX_BIG, - b_size: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_big_add_small( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - b: *const i64, - b_size: u64, - b_sl: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_big_add_small2( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - b: *const i64, - b_size: u64, - b_sl: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_big_sub( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - b: *const VEC_ZNX_BIG, - b_size: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_big_sub_small_b( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - b: *const i64, - b_size: u64, - b_sl: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_big_sub_small_a( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - b: *const VEC_ZNX_BIG, - b_size: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_big_sub_small2( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - b: *const i64, - b_size: u64, - b_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_normalize_base2k_tmp_bytes(module: *const MODULE) -> u64; -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_normalize_base2k( - module: *const MODULE, - log2_base2k: u64, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_range_normalize_base2k( - module: *const MODULE, - log2_base2k: u64, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const VEC_ZNX_BIG, - a_range_begin: u64, - a_range_xend: u64, - a_range_step: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_range_normalize_base2k_tmp_bytes(module: *const MODULE) -> u64; -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_automorphism( - module: *const MODULE, - p: i64, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_rotate( - module: *const MODULE, - p: i64, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - ); -} +use crate::ffi::module::MODULE; + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct vec_znx_big_t { + _unused: [u8; 0], +} +pub type VEC_ZNX_BIG = vec_znx_big_t; + +unsafe extern "C" { + pub unsafe fn bytes_of_vec_znx_big(module: *const MODULE, size: u64) -> u64; +} +unsafe extern "C" { + pub unsafe fn new_vec_znx_big(module: *const MODULE, size: u64) -> *mut VEC_ZNX_BIG; +} +unsafe extern "C" { + pub unsafe fn delete_vec_znx_big(res: *mut VEC_ZNX_BIG); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_add( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + b: *const VEC_ZNX_BIG, + b_size: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_big_add_small( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + b: *const i64, + b_size: u64, + b_sl: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_big_add_small2( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + b: *const i64, + b_size: u64, + b_sl: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_big_sub( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + b: *const VEC_ZNX_BIG, + b_size: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_big_sub_small_b( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + b: *const i64, + b_size: u64, + b_sl: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_big_sub_small_a( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + b: *const VEC_ZNX_BIG, + b_size: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_big_sub_small2( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + b: *const i64, + b_size: u64, + b_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_normalize_base2k_tmp_bytes(module: *const MODULE) -> u64; +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_normalize_base2k( + module: *const MODULE, + log2_base2k: u64, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_range_normalize_base2k( + module: *const MODULE, + log2_base2k: u64, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const VEC_ZNX_BIG, + a_range_begin: u64, + a_range_xend: u64, + a_range_step: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_range_normalize_base2k_tmp_bytes(module: *const MODULE) -> u64; +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_automorphism( + module: *const MODULE, + p: i64, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_rotate( + module: *const MODULE, + p: i64, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + ); +} diff --git a/base2k/src/ffi/vec_znx_dft.rs b/backend/src/ffi/vec_znx_dft.rs similarity index 96% rename from base2k/src/ffi/vec_znx_dft.rs rename to backend/src/ffi/vec_znx_dft.rs index 71583f7..8f427bd 100644 --- a/base2k/src/ffi/vec_znx_dft.rs +++ b/backend/src/ffi/vec_znx_dft.rs @@ -1,86 +1,86 @@ -use crate::ffi::module::MODULE; -use crate::ffi::vec_znx_big::VEC_ZNX_BIG; - -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct vec_znx_dft_t { - _unused: [u8; 0], -} -pub type VEC_ZNX_DFT = vec_znx_dft_t; - -unsafe extern "C" { - pub unsafe fn bytes_of_vec_znx_dft(module: *const MODULE, size: u64) -> u64; -} -unsafe extern "C" { - pub unsafe fn new_vec_znx_dft(module: *const MODULE, size: u64) -> *mut VEC_ZNX_DFT; -} -unsafe extern "C" { - pub unsafe fn delete_vec_znx_dft(res: *mut VEC_ZNX_DFT); -} - -unsafe extern "C" { - pub unsafe fn vec_dft_zero(module: *const MODULE, res: *mut VEC_ZNX_DFT, res_size: u64); -} -unsafe extern "C" { - pub unsafe fn vec_dft_add( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - res_size: u64, - a: *const VEC_ZNX_DFT, - a_size: u64, - b: *const VEC_ZNX_DFT, - b_size: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_dft_sub( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - res_size: u64, - a: *const VEC_ZNX_DFT, - a_size: u64, - b: *const VEC_ZNX_DFT, - b_size: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_dft(module: *const MODULE, res: *mut VEC_ZNX_DFT, res_size: u64, a: *const i64, a_size: u64, a_sl: u64); -} -unsafe extern "C" { - pub unsafe fn vec_znx_idft( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a_dft: *const VEC_ZNX_DFT, - a_size: u64, - tmp: *mut u8, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_idft_tmp_bytes(module: *const MODULE) -> u64; -} -unsafe extern "C" { - pub unsafe fn vec_znx_idft_tmp_a( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a_dft: *mut VEC_ZNX_DFT, - a_size: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_dft_automorphism( - module: *const MODULE, - d: i64, - res_dft: *mut VEC_ZNX_DFT, - res_size: u64, - a_dft: *const VEC_ZNX_DFT, - a_size: u64, - tmp: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_dft_automorphism_tmp_bytes(module: *const MODULE) -> u64; -} +use crate::ffi::module::MODULE; +use crate::ffi::vec_znx_big::VEC_ZNX_BIG; + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct vec_znx_dft_t { + _unused: [u8; 0], +} +pub type VEC_ZNX_DFT = vec_znx_dft_t; + +unsafe extern "C" { + pub unsafe fn bytes_of_vec_znx_dft(module: *const MODULE, size: u64) -> u64; +} +unsafe extern "C" { + pub unsafe fn new_vec_znx_dft(module: *const MODULE, size: u64) -> *mut VEC_ZNX_DFT; +} +unsafe extern "C" { + pub unsafe fn delete_vec_znx_dft(res: *mut VEC_ZNX_DFT); +} + +unsafe extern "C" { + pub unsafe fn vec_dft_zero(module: *const MODULE, res: *mut VEC_ZNX_DFT, res_size: u64); +} +unsafe extern "C" { + pub unsafe fn vec_dft_add( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + res_size: u64, + a: *const VEC_ZNX_DFT, + a_size: u64, + b: *const VEC_ZNX_DFT, + b_size: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_dft_sub( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + res_size: u64, + a: *const VEC_ZNX_DFT, + a_size: u64, + b: *const VEC_ZNX_DFT, + b_size: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_dft(module: *const MODULE, res: *mut VEC_ZNX_DFT, res_size: u64, a: *const i64, a_size: u64, a_sl: u64); +} +unsafe extern "C" { + pub unsafe fn vec_znx_idft( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a_dft: *const VEC_ZNX_DFT, + a_size: u64, + tmp: *mut u8, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_idft_tmp_bytes(module: *const MODULE) -> u64; +} +unsafe extern "C" { + pub unsafe fn vec_znx_idft_tmp_a( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a_dft: *mut VEC_ZNX_DFT, + a_size: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_dft_automorphism( + module: *const MODULE, + d: i64, + res_dft: *mut VEC_ZNX_DFT, + res_size: u64, + a_dft: *const VEC_ZNX_DFT, + a_size: u64, + tmp: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_dft_automorphism_tmp_bytes(module: *const MODULE) -> u64; +} diff --git a/base2k/src/ffi/vmp.rs b/backend/src/ffi/vmp.rs similarity index 95% rename from base2k/src/ffi/vmp.rs rename to backend/src/ffi/vmp.rs index 1d8f47c..fc8a7ae 100644 --- a/base2k/src/ffi/vmp.rs +++ b/backend/src/ffi/vmp.rs @@ -1,165 +1,165 @@ -use crate::ffi::module::MODULE; -use crate::ffi::vec_znx_big::VEC_ZNX_BIG; -use crate::ffi::vec_znx_dft::VEC_ZNX_DFT; - -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct vmp_pmat_t { - _unused: [u8; 0], -} - -// [rows][cols] = [#Decomposition][#Limbs] -pub type VMP_PMAT = vmp_pmat_t; - -unsafe extern "C" { - pub unsafe fn bytes_of_vmp_pmat(module: *const MODULE, nrows: u64, ncols: u64) -> u64; -} -unsafe extern "C" { - pub unsafe fn new_vmp_pmat(module: *const MODULE, nrows: u64, ncols: u64) -> *mut VMP_PMAT; -} -unsafe extern "C" { - pub unsafe fn delete_vmp_pmat(res: *mut VMP_PMAT); -} - -unsafe extern "C" { - pub unsafe fn vmp_apply_dft( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - res_size: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - pmat: *const VMP_PMAT, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_apply_dft_add( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - res_size: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - pmat: *const VMP_PMAT, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_apply_dft_tmp_bytes(module: *const MODULE, res_size: u64, a_size: u64, nrows: u64, ncols: u64) -> u64; -} - -unsafe extern "C" { - pub unsafe fn vmp_apply_dft_to_dft( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - res_size: u64, - a_dft: *const VEC_ZNX_DFT, - a_size: u64, - pmat: *const VMP_PMAT, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_apply_dft_to_dft_add( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - res_size: u64, - a_dft: *const VEC_ZNX_DFT, - a_size: u64, - pmat: *const VMP_PMAT, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_apply_dft_to_dft_tmp_bytes( - module: *const MODULE, - res_size: u64, - a_size: u64, - nrows: u64, - ncols: u64, - ) -> u64; -} - -unsafe extern "C" { - pub unsafe fn vmp_prepare_contiguous( - module: *const MODULE, - pmat: *mut VMP_PMAT, - mat: *const i64, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_prepare_dblptr( - module: *const MODULE, - pmat: *mut VMP_PMAT, - mat: *const *const i64, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_prepare_row( - module: *const MODULE, - pmat: *mut VMP_PMAT, - row: *const i64, - row_i: u64, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_prepare_row_dft( - module: *const MODULE, - pmat: *mut VMP_PMAT, - row: *const VEC_ZNX_DFT, - row_i: u64, - nrows: u64, - ncols: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_extract_row_dft( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - pmat: *const VMP_PMAT, - row_i: u64, - nrows: u64, - ncols: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_extract_row( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - pmat: *const VMP_PMAT, - row_i: u64, - nrows: u64, - ncols: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_prepare_tmp_bytes(module: *const MODULE, nrows: u64, ncols: u64) -> u64; -} +use crate::ffi::module::MODULE; +use crate::ffi::vec_znx_big::VEC_ZNX_BIG; +use crate::ffi::vec_znx_dft::VEC_ZNX_DFT; + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct vmp_pmat_t { + _unused: [u8; 0], +} + +// [rows][cols] = [#Decomposition][#Limbs] +pub type VMP_PMAT = vmp_pmat_t; + +unsafe extern "C" { + pub unsafe fn bytes_of_vmp_pmat(module: *const MODULE, nrows: u64, ncols: u64) -> u64; +} +unsafe extern "C" { + pub unsafe fn new_vmp_pmat(module: *const MODULE, nrows: u64, ncols: u64) -> *mut VMP_PMAT; +} +unsafe extern "C" { + pub unsafe fn delete_vmp_pmat(res: *mut VMP_PMAT); +} + +unsafe extern "C" { + pub unsafe fn vmp_apply_dft( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + res_size: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + pmat: *const VMP_PMAT, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_apply_dft_add( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + res_size: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + pmat: *const VMP_PMAT, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_apply_dft_tmp_bytes(module: *const MODULE, res_size: u64, a_size: u64, nrows: u64, ncols: u64) -> u64; +} + +unsafe extern "C" { + pub unsafe fn vmp_apply_dft_to_dft( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + res_size: u64, + a_dft: *const VEC_ZNX_DFT, + a_size: u64, + pmat: *const VMP_PMAT, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_apply_dft_to_dft_add( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + res_size: u64, + a_dft: *const VEC_ZNX_DFT, + a_size: u64, + pmat: *const VMP_PMAT, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_apply_dft_to_dft_tmp_bytes( + module: *const MODULE, + res_size: u64, + a_size: u64, + nrows: u64, + ncols: u64, + ) -> u64; +} + +unsafe extern "C" { + pub unsafe fn vmp_prepare_contiguous( + module: *const MODULE, + pmat: *mut VMP_PMAT, + mat: *const i64, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_prepare_dblptr( + module: *const MODULE, + pmat: *mut VMP_PMAT, + mat: *const *const i64, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_prepare_row( + module: *const MODULE, + pmat: *mut VMP_PMAT, + row: *const i64, + row_i: u64, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_prepare_row_dft( + module: *const MODULE, + pmat: *mut VMP_PMAT, + row: *const VEC_ZNX_DFT, + row_i: u64, + nrows: u64, + ncols: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_extract_row_dft( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + pmat: *const VMP_PMAT, + row_i: u64, + nrows: u64, + ncols: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_extract_row( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + pmat: *const VMP_PMAT, + row_i: u64, + nrows: u64, + ncols: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_prepare_tmp_bytes(module: *const MODULE, nrows: u64, ncols: u64) -> u64; +} diff --git a/base2k/src/ffi/znx.rs b/backend/src/ffi/znx.rs similarity index 97% rename from base2k/src/ffi/znx.rs rename to backend/src/ffi/znx.rs index f4bbeca..dc30db6 100644 --- a/base2k/src/ffi/znx.rs +++ b/backend/src/ffi/znx.rs @@ -1,76 +1,76 @@ -use crate::ffi::module::MODULE; - -unsafe extern "C" { - pub unsafe fn znx_add_i64_ref(nn: u64, res: *mut i64, a: *const i64, b: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_add_i64_avx(nn: u64, res: *mut i64, a: *const i64, b: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_sub_i64_ref(nn: u64, res: *mut i64, a: *const i64, b: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_sub_i64_avx(nn: u64, res: *mut i64, a: *const i64, b: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_negate_i64_ref(nn: u64, res: *mut i64, a: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_negate_i64_avx(nn: u64, res: *mut i64, a: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_copy_i64_ref(nn: u64, res: *mut i64, a: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_zero_i64_ref(nn: u64, res: *mut i64); -} -unsafe extern "C" { - pub unsafe fn rnx_divide_by_m_ref(nn: u64, m: f64, res: *mut f64, a: *const f64); -} -unsafe extern "C" { - pub unsafe fn rnx_divide_by_m_avx(nn: u64, m: f64, res: *mut f64, a: *const f64); -} -unsafe extern "C" { - pub unsafe fn rnx_rotate_f64(nn: u64, p: i64, res: *mut f64, in_: *const f64); -} -unsafe extern "C" { - pub unsafe fn znx_rotate_i64(nn: u64, p: i64, res: *mut i64, in_: *const i64); -} -unsafe extern "C" { - pub unsafe fn rnx_rotate_inplace_f64(nn: u64, p: i64, res: *mut f64); -} -unsafe extern "C" { - pub unsafe fn znx_rotate_inplace_i64(nn: u64, p: i64, res: *mut i64); -} -unsafe extern "C" { - pub unsafe fn rnx_automorphism_f64(nn: u64, p: i64, res: *mut f64, in_: *const f64); -} -unsafe extern "C" { - pub unsafe fn znx_automorphism_i64(nn: u64, p: i64, res: *mut i64, in_: *const i64); -} -unsafe extern "C" { - pub unsafe fn rnx_automorphism_inplace_f64(nn: u64, p: i64, res: *mut f64); -} -unsafe extern "C" { - pub unsafe fn znx_automorphism_inplace_i64(nn: u64, p: i64, res: *mut i64); -} -unsafe extern "C" { - pub unsafe fn rnx_mul_xp_minus_one(nn: u64, p: i64, res: *mut f64, in_: *const f64); -} -unsafe extern "C" { - pub unsafe fn znx_mul_xp_minus_one(nn: u64, p: i64, res: *mut i64, in_: *const i64); -} -unsafe extern "C" { - pub unsafe fn rnx_mul_xp_minus_one_inplace(nn: u64, p: i64, res: *mut f64); -} -unsafe extern "C" { - pub unsafe fn znx_normalize(nn: u64, base_k: u64, out: *mut i64, carry_out: *mut i64, in_: *const i64, carry_in: *const i64); -} - -unsafe extern "C" { - pub unsafe fn znx_small_single_product(module: *const MODULE, res: *mut i64, a: *const i64, b: *const i64, tmp: *mut u8); -} - -unsafe extern "C" { - pub unsafe fn znx_small_single_product_tmp_bytes(module: *const MODULE) -> u64; -} +use crate::ffi::module::MODULE; + +unsafe extern "C" { + pub unsafe fn znx_add_i64_ref(nn: u64, res: *mut i64, a: *const i64, b: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_add_i64_avx(nn: u64, res: *mut i64, a: *const i64, b: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_sub_i64_ref(nn: u64, res: *mut i64, a: *const i64, b: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_sub_i64_avx(nn: u64, res: *mut i64, a: *const i64, b: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_negate_i64_ref(nn: u64, res: *mut i64, a: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_negate_i64_avx(nn: u64, res: *mut i64, a: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_copy_i64_ref(nn: u64, res: *mut i64, a: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_zero_i64_ref(nn: u64, res: *mut i64); +} +unsafe extern "C" { + pub unsafe fn rnx_divide_by_m_ref(nn: u64, m: f64, res: *mut f64, a: *const f64); +} +unsafe extern "C" { + pub unsafe fn rnx_divide_by_m_avx(nn: u64, m: f64, res: *mut f64, a: *const f64); +} +unsafe extern "C" { + pub unsafe fn rnx_rotate_f64(nn: u64, p: i64, res: *mut f64, in_: *const f64); +} +unsafe extern "C" { + pub unsafe fn znx_rotate_i64(nn: u64, p: i64, res: *mut i64, in_: *const i64); +} +unsafe extern "C" { + pub unsafe fn rnx_rotate_inplace_f64(nn: u64, p: i64, res: *mut f64); +} +unsafe extern "C" { + pub unsafe fn znx_rotate_inplace_i64(nn: u64, p: i64, res: *mut i64); +} +unsafe extern "C" { + pub unsafe fn rnx_automorphism_f64(nn: u64, p: i64, res: *mut f64, in_: *const f64); +} +unsafe extern "C" { + pub unsafe fn znx_automorphism_i64(nn: u64, p: i64, res: *mut i64, in_: *const i64); +} +unsafe extern "C" { + pub unsafe fn rnx_automorphism_inplace_f64(nn: u64, p: i64, res: *mut f64); +} +unsafe extern "C" { + pub unsafe fn znx_automorphism_inplace_i64(nn: u64, p: i64, res: *mut i64); +} +unsafe extern "C" { + pub unsafe fn rnx_mul_xp_minus_one(nn: u64, p: i64, res: *mut f64, in_: *const f64); +} +unsafe extern "C" { + pub unsafe fn znx_mul_xp_minus_one(nn: u64, p: i64, res: *mut i64, in_: *const i64); +} +unsafe extern "C" { + pub unsafe fn rnx_mul_xp_minus_one_inplace(nn: u64, p: i64, res: *mut f64); +} +unsafe extern "C" { + pub unsafe fn znx_normalize(nn: u64, base_k: u64, out: *mut i64, carry_out: *mut i64, in_: *const i64, carry_in: *const i64); +} + +unsafe extern "C" { + pub unsafe fn znx_small_single_product(module: *const MODULE, res: *mut i64, a: *const i64, b: *const i64, tmp: *mut u8); +} + +unsafe extern "C" { + pub unsafe fn znx_small_single_product_tmp_bytes(module: *const MODULE) -> u64; +} diff --git a/base2k/src/lib.rs b/backend/src/lib.rs similarity index 100% rename from base2k/src/lib.rs rename to backend/src/lib.rs diff --git a/base2k/src/mat_znx_dft.rs b/backend/src/mat_znx_dft.rs similarity index 100% rename from base2k/src/mat_znx_dft.rs rename to backend/src/mat_znx_dft.rs diff --git a/base2k/src/mat_znx_dft_ops.rs b/backend/src/mat_znx_dft_ops.rs similarity index 97% rename from base2k/src/mat_znx_dft_ops.rs rename to backend/src/mat_znx_dft_ops.rs index 24be2e2..e73b782 100644 --- a/base2k/src/mat_znx_dft_ops.rs +++ b/backend/src/mat_znx_dft_ops.rs @@ -310,10 +310,11 @@ impl MatZnxDftOps for Module { } fn vmp_apply_add(&self, res: &mut R, a: &A, b: &B, scratch: &mut Scratch) - where - R: VecZnxDftToMut, - A: VecZnxDftToRef, - B: MatZnxDftToRef { + where + R: VecZnxDftToMut, + A: VecZnxDftToRef, + B: MatZnxDftToRef, + { let mut res: VecZnxDft<&mut [u8], _> = res.to_mut(); let a: VecZnxDft<&[u8], _> = a.to_ref(); let b: MatZnxDft<&[u8], _> = b.to_ref(); @@ -375,7 +376,7 @@ mod tests { #[test] fn vmp_prepare_row() { let module: Module = Module::::new(16); - let log_base2k: usize = 8; + let basek: usize = 8; let mat_rows: usize = 4; let mat_cols_in: usize = 2; let mat_cols_out: usize = 2; @@ -389,7 +390,7 @@ mod tests { for row_i in 0..mat_rows { let mut source: Source = Source::new([0u8; 32]); (0..mat_cols_out).for_each(|col_out| { - a.fill_uniform(log_base2k, col_out, mat_size, &mut source); + a.fill_uniform(basek, col_out, mat_size, &mut source); module.vec_znx_dft(&mut a_dft, col_out, &a, col_out); }); module.vmp_prepare_row(&mut mat, row_i, col_in, &a_dft); @@ -405,7 +406,7 @@ mod tests { let n: usize = 1 << log_n; let module: Module = Module::::new(n); - let log_base2k: usize = 15; + let basek: usize = 15; let a_size: usize = 5; let mat_size: usize = 6; let res_size: usize = 5; @@ -470,7 +471,7 @@ mod tests { let mut res_have: VecZnx> = module.new_vec_znx(res_cols, res_size); (0..mat_cols_out).for_each(|i| { module.vec_znx_idft_tmp_a(&mut c_big, i, &mut c_dft, i); - module.vec_znx_big_normalize(log_base2k, &mut res_have, i, &c_big, i, scratch.borrow()); + module.vec_znx_big_normalize(basek, &mut res_have, i, &c_big, i, scratch.borrow()); }); (0..mat_cols_out).for_each(|col_i| { @@ -478,7 +479,7 @@ mod tests { (0..a_cols).for_each(|i| { res_want_vi64[(i + 1) + (1 + i * mat_cols_out + col_i)] = 1; }); - res_have.decode_vec_i64(col_i, log_base2k, log_base2k * 3, &mut res_have_vi64); + res_have.decode_vec_i64(col_i, basek, basek * 3, &mut res_have_vi64); assert_eq!(res_have_vi64, res_want_vi64); }); }); diff --git a/base2k/src/module.rs b/backend/src/module.rs similarity index 100% rename from base2k/src/module.rs rename to backend/src/module.rs diff --git a/base2k/src/sampling.rs b/backend/src/sampling.rs similarity index 73% rename from base2k/src/sampling.rs rename to backend/src/sampling.rs index b4e1489..fd8c577 100644 --- a/base2k/src/sampling.rs +++ b/backend/src/sampling.rs @@ -4,16 +4,16 @@ use rand_distr::{Distribution, Normal}; use sampling::source::Source; pub trait FillUniform { - /// Fills the first `size` size with uniform values in \[-2^{log_base2k-1}, 2^{log_base2k-1}\] - fn fill_uniform(&mut self, log_base2k: usize, col_i: usize, size: usize, source: &mut Source); + /// Fills the first `size` size with uniform values in \[-2^{basek-1}, 2^{basek-1}\] + fn fill_uniform(&mut self, basek: usize, col_i: usize, size: usize, source: &mut Source); } pub trait FillDistF64 { fn fill_dist_f64>( &mut self, - log_base2k: usize, + basek: usize, col_i: usize, - log_k: usize, + k: usize, source: &mut Source, dist: D, bound: f64, @@ -21,12 +21,12 @@ pub trait FillDistF64 { } pub trait AddDistF64 { - /// Adds vector sampled according to the provided distribution, scaled by 2^{-log_k} and bounded to \[-bound, bound\]. + /// Adds vector sampled according to the provided distribution, scaled by 2^{-k} and bounded to \[-bound, bound\]. fn add_dist_f64>( &mut self, - log_base2k: usize, + basek: usize, col_i: usize, - log_k: usize, + k: usize, source: &mut Source, dist: D, bound: f64, @@ -34,21 +34,21 @@ pub trait AddDistF64 { } pub trait FillNormal { - fn fill_normal(&mut self, log_base2k: usize, col_i: usize, log_k: usize, source: &mut Source, sigma: f64, bound: f64); + fn fill_normal(&mut self, basek: usize, col_i: usize, k: usize, source: &mut Source, sigma: f64, bound: f64); } pub trait AddNormal { - /// Adds a discrete normal vector scaled by 2^{-log_k} with the provided standard deviation and bounded to \[-bound, bound\]. - fn add_normal(&mut self, log_base2k: usize, col_i: usize, log_k: usize, source: &mut Source, sigma: f64, bound: f64); + /// Adds a discrete normal vector scaled by 2^{-k} with the provided standard deviation and bounded to \[-bound, bound\]. + fn add_normal(&mut self, basek: usize, col_i: usize, k: usize, source: &mut Source, sigma: f64, bound: f64); } impl FillUniform for VecZnx where VecZnx: VecZnxToMut, { - fn fill_uniform(&mut self, log_base2k: usize, col_i: usize, size: usize, source: &mut Source) { + fn fill_uniform(&mut self, basek: usize, col_i: usize, size: usize, source: &mut Source) { let mut a: VecZnx<&mut [u8]> = self.to_mut(); - let base2k: u64 = 1 << log_base2k; + let base2k: u64 = 1 << basek; let mask: u64 = base2k - 1; let base2k_half: i64 = (base2k >> 1) as i64; (0..size).for_each(|j| { @@ -65,9 +65,9 @@ where { fn fill_dist_f64>( &mut self, - log_base2k: usize, + basek: usize, col_i: usize, - log_k: usize, + k: usize, source: &mut Source, dist: D, bound: f64, @@ -79,16 +79,16 @@ where (bound.log2().ceil() as i64) ); - let limb: usize = (log_k + log_base2k - 1) / log_base2k - 1; - let log_base2k_rem: usize = (limb + 1) * log_base2k - log_k; + let limb: usize = (k + basek - 1) / basek - 1; + let basek_rem: usize = (limb + 1) * basek - k; - if log_base2k_rem != 0 { + if basek_rem != 0 { a.at_mut(col_i, limb).iter_mut().for_each(|a| { let mut dist_f64: f64 = dist.sample(source); while dist_f64.abs() > bound { dist_f64 = dist.sample(source) } - *a = (dist_f64.round() as i64) << log_base2k_rem; + *a = (dist_f64.round() as i64) << basek_rem; }); } else { a.at_mut(col_i, limb).iter_mut().for_each(|a| { @@ -108,9 +108,9 @@ where { fn add_dist_f64>( &mut self, - log_base2k: usize, + basek: usize, col_i: usize, - log_k: usize, + k: usize, source: &mut Source, dist: D, bound: f64, @@ -122,16 +122,16 @@ where (bound.log2().ceil() as i64) ); - let limb: usize = (log_k + log_base2k - 1) / log_base2k - 1; - let log_base2k_rem: usize = (limb + 1) * log_base2k - log_k; + let limb: usize = (k + basek - 1) / basek - 1; + let basek_rem: usize = (limb + 1) * basek - k; - if log_base2k_rem != 0 { + if basek_rem != 0 { a.at_mut(col_i, limb).iter_mut().for_each(|a| { let mut dist_f64: f64 = dist.sample(source); while dist_f64.abs() > bound { dist_f64 = dist.sample(source) } - *a += (dist_f64.round() as i64) << log_base2k_rem; + *a += (dist_f64.round() as i64) << basek_rem; }); } else { a.at_mut(col_i, limb).iter_mut().for_each(|a| { @@ -149,11 +149,11 @@ impl FillNormal for VecZnx where VecZnx: VecZnxToMut, { - fn fill_normal(&mut self, log_base2k: usize, col_i: usize, log_k: usize, source: &mut Source, sigma: f64, bound: f64) { + fn fill_normal(&mut self, basek: usize, col_i: usize, k: usize, source: &mut Source, sigma: f64, bound: f64) { self.fill_dist_f64( - log_base2k, + basek, col_i, - log_k, + k, source, Normal::new(0.0, sigma).unwrap(), bound, @@ -165,11 +165,11 @@ impl AddNormal for VecZnx where VecZnx: VecZnxToMut, { - fn add_normal(&mut self, log_base2k: usize, col_i: usize, log_k: usize, source: &mut Source, sigma: f64, bound: f64) { + fn add_normal(&mut self, basek: usize, col_i: usize, k: usize, source: &mut Source, sigma: f64, bound: f64) { self.add_dist_f64( - log_base2k, + basek, col_i, - log_k, + k, source, Normal::new(0.0, sigma).unwrap(), bound, @@ -183,9 +183,9 @@ where { fn fill_dist_f64>( &mut self, - log_base2k: usize, + basek: usize, col_i: usize, - log_k: usize, + k: usize, source: &mut Source, dist: D, bound: f64, @@ -197,16 +197,16 @@ where (bound.log2().ceil() as i64) ); - let limb: usize = (log_k + log_base2k - 1) / log_base2k - 1; - let log_base2k_rem: usize = (limb + 1) * log_base2k - log_k; + let limb: usize = (k + basek - 1) / basek - 1; + let basek_rem: usize = (limb + 1) * basek - k; - if log_base2k_rem != 0 { + if basek_rem != 0 { a.at_mut(col_i, limb).iter_mut().for_each(|a| { let mut dist_f64: f64 = dist.sample(source); while dist_f64.abs() > bound { dist_f64 = dist.sample(source) } - *a = (dist_f64.round() as i64) << log_base2k_rem; + *a = (dist_f64.round() as i64) << basek_rem; }); } else { a.at_mut(col_i, limb).iter_mut().for_each(|a| { @@ -226,9 +226,9 @@ where { fn add_dist_f64>( &mut self, - log_base2k: usize, + basek: usize, col_i: usize, - log_k: usize, + k: usize, source: &mut Source, dist: D, bound: f64, @@ -240,16 +240,16 @@ where (bound.log2().ceil() as i64) ); - let limb: usize = (log_k + log_base2k - 1) / log_base2k - 1; - let log_base2k_rem: usize = (limb + 1) * log_base2k - log_k; + let limb: usize = (k + basek - 1) / basek - 1; + let basek_rem: usize = (limb + 1) * basek - k; - if log_base2k_rem != 0 { + if basek_rem != 0 { a.at_mut(col_i, limb).iter_mut().for_each(|a| { let mut dist_f64: f64 = dist.sample(source); while dist_f64.abs() > bound { dist_f64 = dist.sample(source) } - *a += (dist_f64.round() as i64) << log_base2k_rem; + *a += (dist_f64.round() as i64) << basek_rem; }); } else { a.at_mut(col_i, limb).iter_mut().for_each(|a| { @@ -267,11 +267,11 @@ impl FillNormal for VecZnxBig where VecZnxBig: VecZnxBigToMut, { - fn fill_normal(&mut self, log_base2k: usize, col_i: usize, log_k: usize, source: &mut Source, sigma: f64, bound: f64) { + fn fill_normal(&mut self, basek: usize, col_i: usize, k: usize, source: &mut Source, sigma: f64, bound: f64) { self.fill_dist_f64( - log_base2k, + basek, col_i, - log_k, + k, source, Normal::new(0.0, sigma).unwrap(), bound, @@ -283,11 +283,11 @@ impl AddNormal for VecZnxBig where VecZnxBig: VecZnxBigToMut, { - fn add_normal(&mut self, log_base2k: usize, col_i: usize, log_k: usize, source: &mut Source, sigma: f64, bound: f64) { + fn add_normal(&mut self, basek: usize, col_i: usize, k: usize, source: &mut Source, sigma: f64, bound: f64) { self.add_dist_f64( - log_base2k, + basek, col_i, - log_k, + k, source, Normal::new(0.0, sigma).unwrap(), bound, @@ -307,7 +307,7 @@ mod tests { fn vec_znx_fill_uniform() { let n: usize = 4096; let module: Module = Module::::new(n); - let log_base2k: usize = 17; + let basek: usize = 17; let size: usize = 5; let mut source: Source = Source::new([0u8; 32]); let cols: usize = 2; @@ -315,14 +315,14 @@ mod tests { let one_12_sqrt: f64 = 0.28867513459481287; (0..cols).for_each(|col_i| { let mut a: VecZnx<_> = module.new_vec_znx(cols, size); - a.fill_uniform(log_base2k, col_i, size, &mut source); + a.fill_uniform(basek, col_i, size, &mut source); (0..cols).for_each(|col_j| { if col_j != col_i { (0..size).for_each(|limb_i| { assert_eq!(a.at(col_j, limb_i), zero); }) } else { - let std: f64 = a.std(col_i, log_base2k); + let std: f64 = a.std(col_i, basek); assert!( (std - one_12_sqrt).abs() < 0.01, "std={} ~!= {}", @@ -338,25 +338,25 @@ mod tests { fn vec_znx_add_normal() { let n: usize = 4096; let module: Module = Module::::new(n); - let log_base2k: usize = 17; - let log_k: usize = 2 * 17; + let basek: usize = 17; + let k: usize = 2 * 17; let size: usize = 5; let sigma: f64 = 3.2; let bound: f64 = 6.0 * sigma; let mut source: Source = Source::new([0u8; 32]); let cols: usize = 2; let zero: Vec = vec![0; n]; - let k_f64: f64 = (1u64 << log_k as u64) as f64; + let k_f64: f64 = (1u64 << k as u64) as f64; (0..cols).for_each(|col_i| { let mut a: VecZnx<_> = module.new_vec_znx(cols, size); - a.add_normal(log_base2k, col_i, log_k, &mut source, sigma, bound); + a.add_normal(basek, col_i, k, &mut source, sigma, bound); (0..cols).for_each(|col_j| { if col_j != col_i { (0..size).for_each(|limb_i| { assert_eq!(a.at(col_j, limb_i), zero); }) } else { - let std: f64 = a.std(col_i, log_base2k) * k_f64; + let std: f64 = a.std(col_i, basek) * k_f64; assert!((std - sigma).abs() < 0.1, "std={} ~!= {}", std, sigma); } }) diff --git a/base2k/src/scalar_znx.rs b/backend/src/scalar_znx.rs similarity index 100% rename from base2k/src/scalar_znx.rs rename to backend/src/scalar_znx.rs diff --git a/base2k/src/scalar_znx_dft.rs b/backend/src/scalar_znx_dft.rs similarity index 100% rename from base2k/src/scalar_znx_dft.rs rename to backend/src/scalar_znx_dft.rs diff --git a/base2k/src/scalar_znx_dft_ops.rs b/backend/src/scalar_znx_dft_ops.rs similarity index 100% rename from base2k/src/scalar_znx_dft_ops.rs rename to backend/src/scalar_znx_dft_ops.rs diff --git a/base2k/src/stats.rs b/backend/src/stats.rs similarity index 80% rename from base2k/src/stats.rs rename to backend/src/stats.rs index 8db40f2..f5aa26a 100644 --- a/base2k/src/stats.rs +++ b/backend/src/stats.rs @@ -1,32 +1,32 @@ -use crate::znx_base::ZnxInfos; -use crate::{Decoding, VecZnx}; -use rug::Float; -use rug::float::Round; -use rug::ops::{AddAssignRound, DivAssignRound, SubAssignRound}; - -pub trait Stats { - /// Returns the standard devaition of the i-th polynomial. - fn std(&self, col_i: usize, log_base2k: usize) -> f64; -} - -impl> Stats for VecZnx { - fn std(&self, col_i: usize, log_base2k: usize) -> f64 { - let prec: u32 = (self.size() * log_base2k) as u32; - let mut data: Vec = (0..self.n()).map(|_| Float::with_val(prec, 0)).collect(); - self.decode_vec_float(col_i, log_base2k, &mut data); - // std = sqrt(sum((xi - avg)^2) / n) - let mut avg: Float = Float::with_val(prec, 0); - data.iter().for_each(|x| { - avg.add_assign_round(x, Round::Nearest); - }); - avg.div_assign_round(Float::with_val(prec, data.len()), Round::Nearest); - data.iter_mut().for_each(|x| { - x.sub_assign_round(&avg, Round::Nearest); - }); - let mut std: Float = Float::with_val(prec, 0); - data.iter().for_each(|x| std += x * x); - std.div_assign_round(Float::with_val(prec, data.len()), Round::Nearest); - std = std.sqrt(); - std.to_f64() - } -} +use crate::znx_base::ZnxInfos; +use crate::{Decoding, VecZnx}; +use rug::Float; +use rug::float::Round; +use rug::ops::{AddAssignRound, DivAssignRound, SubAssignRound}; + +pub trait Stats { + /// Returns the standard devaition of the i-th polynomial. + fn std(&self, col_i: usize, basek: usize) -> f64; +} + +impl> Stats for VecZnx { + fn std(&self, col_i: usize, basek: usize) -> f64 { + let prec: u32 = (self.size() * basek) as u32; + let mut data: Vec = (0..self.n()).map(|_| Float::with_val(prec, 0)).collect(); + self.decode_vec_float(col_i, basek, &mut data); + // std = sqrt(sum((xi - avg)^2) / n) + let mut avg: Float = Float::with_val(prec, 0); + data.iter().for_each(|x| { + avg.add_assign_round(x, Round::Nearest); + }); + avg.div_assign_round(Float::with_val(prec, data.len()), Round::Nearest); + data.iter_mut().for_each(|x| { + x.sub_assign_round(&avg, Round::Nearest); + }); + let mut std: Float = Float::with_val(prec, 0); + data.iter().for_each(|x| std += x * x); + std.div_assign_round(Float::with_val(prec, data.len()), Round::Nearest); + std = std.sqrt(); + std.to_f64() + } +} diff --git a/base2k/src/vec_znx.rs b/backend/src/vec_znx.rs similarity index 83% rename from base2k/src/vec_znx.rs rename to backend/src/vec_znx.rs index d4b0b9c..950fae9 100644 --- a/base2k/src/vec_znx.rs +++ b/backend/src/vec_znx.rs @@ -1,6 +1,9 @@ +use itertools::izip; + use crate::DataView; use crate::DataViewMut; use crate::ScalarZnx; +use crate::Scratch; use crate::ZnxSliceSize; use crate::ZnxZero; use crate::alloc_aligned; @@ -68,29 +71,66 @@ impl> ZnxView for VecZnx { type Scalar = i64; } +impl> VecZnx { + pub fn rsh_scratch_space(n: usize) -> usize { + n * std::mem::size_of::() + } +} + impl + AsRef<[u8]>> VecZnx { /// Truncates the precision of the [VecZnx] by k bits. /// /// # Arguments /// - /// * `log_base2k`: the base two logarithm of the coefficients decomposition. + /// * `basek`: the base two logarithm of the coefficients decomposition. /// * `k`: the number of bits of precision to drop. - pub fn trunc_pow2(&mut self, log_base2k: usize, k: usize, col: usize) { + pub fn trunc_pow2(&mut self, basek: usize, k: usize, col: usize) { if k == 0 { return; } - self.size -= k / log_base2k; + self.size -= k / basek; - let k_rem: usize = k % log_base2k; + let k_rem: usize = k % basek; if k_rem != 0 { - let mask: i64 = ((1 << (log_base2k - k_rem - 1)) - 1) << k_rem; + let mask: i64 = ((1 << (basek - k_rem - 1)) - 1) << k_rem; self.at_mut(col, self.size() - 1) .iter_mut() .for_each(|x: &mut i64| *x &= mask) } } + + pub fn rsh(&mut self, basek: usize, k: usize, scratch: &mut Scratch) { + let n: usize = self.n(); + let cols: usize = self.cols(); + let size: usize = self.size(); + let steps: usize = k / basek; + + self.raw_mut().rotate_right(n * steps * cols); + (0..cols).for_each(|i| { + (0..steps).for_each(|j| { + self.zero_at(i, j); + }) + }); + + let k_rem: usize = k % basek; + + if k_rem != 0 { + let (carry, _) = scratch.tmp_slice::(n); + let shift = i64::BITS as usize - k_rem; + (0..cols).for_each(|i| { + carry.fill(0); + (steps..size).for_each(|j| { + izip!(carry.iter_mut(), self.at_mut(i, j).iter_mut()).for_each(|(ci, xi)| { + *xi += *ci << basek; + *ci = (*xi << shift) >> shift; + *xi = (*xi - *ci) >> k_rem; + }); + }); + }) + } + } } impl>> VecZnx { @@ -165,7 +205,7 @@ fn normalize_tmp_bytes(n: usize) -> usize { } #[allow(dead_code)] -fn normalize + AsRef<[u8]>>(log_base2k: usize, a: &mut VecZnx, a_col: usize, tmp_bytes: &mut [u8]) { +fn normalize + AsRef<[u8]>>(basek: usize, a: &mut VecZnx, a_col: usize, tmp_bytes: &mut [u8]) { let n: usize = a.n(); debug_assert!( @@ -187,7 +227,7 @@ fn normalize + AsRef<[u8]>>(log_base2k: usize, a: &mut VecZnx, (0..a.size()).rev().for_each(|i| { znx::znx_normalize( n as u64, - log_base2k as u64, + basek as u64, a.at_mut_ptr(a_col, i), carry_i64.as_mut_ptr(), a.at_mut_ptr(a_col, i), diff --git a/base2k/src/vec_znx_big.rs b/backend/src/vec_znx_big.rs similarity index 100% rename from base2k/src/vec_znx_big.rs rename to backend/src/vec_znx_big.rs diff --git a/base2k/src/vec_znx_big_ops.rs b/backend/src/vec_znx_big_ops.rs similarity index 99% rename from base2k/src/vec_znx_big_ops.rs rename to backend/src/vec_znx_big_ops.rs index 8208c97..d23dc22 100644 --- a/base2k/src/vec_znx_big_ops.rs +++ b/backend/src/vec_znx_big_ops.rs @@ -123,11 +123,11 @@ pub trait VecZnxBigOps { /// /// # Arguments /// - /// * `log_base2k`: normalization basis. + /// * `basek`: normalization basis. /// * `tmp_bytes`: scratch space of size at least [VecZnxBigOps::vec_znx_big_normalize]. fn vec_znx_big_normalize( &self, - log_base2k: usize, + basek: usize, res: &mut R, res_col: usize, a: &A, @@ -532,7 +532,7 @@ impl VecZnxBigOps for Module { fn vec_znx_big_normalize( &self, - log_base2k: usize, + basek: usize, res: &mut R, res_col: usize, a: &A, @@ -561,7 +561,7 @@ impl VecZnxBigOps for Module { unsafe { vec_znx::vec_znx_normalize_base2k( self.ptr, - log_base2k as u64, + basek as u64, res.at_mut_ptr(res_col, 0), res.size() as u64, res.sl() as u64, diff --git a/base2k/src/vec_znx_dft.rs b/backend/src/vec_znx_dft.rs similarity index 100% rename from base2k/src/vec_znx_dft.rs rename to backend/src/vec_znx_dft.rs diff --git a/base2k/src/vec_znx_dft_ops.rs b/backend/src/vec_znx_dft_ops.rs similarity index 100% rename from base2k/src/vec_znx_dft_ops.rs rename to backend/src/vec_znx_dft_ops.rs diff --git a/base2k/src/vec_znx_ops.rs b/backend/src/vec_znx_ops.rs similarity index 97% rename from base2k/src/vec_znx_ops.rs rename to backend/src/vec_znx_ops.rs index b97e6b7..90321a5 100644 --- a/base2k/src/vec_znx_ops.rs +++ b/backend/src/vec_znx_ops.rs @@ -35,13 +35,13 @@ pub trait VecZnxAlloc { pub trait VecZnxOps { /// Normalizes the selected column of `a` and stores the result into the selected column of `res`. - fn vec_znx_normalize(&self, log_base2k: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch) + fn vec_znx_normalize(&self, basek: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch) where R: VecZnxToMut, A: VecZnxToRef; /// Normalizes the selected column of `a`. - fn vec_znx_normalize_inplace(&self, log_base2k: usize, a: &mut A, a_col: usize, scratch: &mut Scratch) + fn vec_znx_normalize_inplace(&self, basek: usize, a: &mut A, a_col: usize, scratch: &mut Scratch) where A: VecZnxToMut; @@ -174,7 +174,7 @@ impl VecZnxAlloc for Module { } impl VecZnxOps for Module { - fn vec_znx_normalize(&self, log_base2k: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch) + fn vec_znx_normalize(&self, basek: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch) where R: VecZnxToMut, A: VecZnxToRef, @@ -193,7 +193,7 @@ impl VecZnxOps for Module { unsafe { vec_znx::vec_znx_normalize_base2k( self.ptr, - log_base2k as u64, + basek as u64, res.at_mut_ptr(res_col, 0), res.size() as u64, res.sl() as u64, @@ -205,7 +205,7 @@ impl VecZnxOps for Module { } } - fn vec_znx_normalize_inplace(&self, log_base2k: usize, a: &mut A, a_col: usize, scratch: &mut Scratch) + fn vec_znx_normalize_inplace(&self, basek: usize, a: &mut A, a_col: usize, scratch: &mut Scratch) where A: VecZnxToMut, { @@ -221,7 +221,7 @@ impl VecZnxOps for Module { unsafe { vec_znx::vec_znx_normalize_base2k( self.ptr, - log_base2k as u64, + basek as u64, a.at_mut_ptr(a_col, 0), a.size() as u64, a.sl() as u64, diff --git a/base2k/src/znx_base.rs b/backend/src/znx_base.rs similarity index 95% rename from base2k/src/znx_base.rs rename to backend/src/znx_base.rs index f618446..daa313d 100644 --- a/base2k/src/znx_base.rs +++ b/backend/src/znx_base.rs @@ -150,7 +150,7 @@ impl Integer for i128 { } //(Jay)Note: `rsh` impl. ignores the column -pub fn rsh(k: usize, log_base2k: usize, a: &mut V, _a_col: usize, scratch: &mut Scratch) +pub fn rsh(k: usize, basek: usize, a: &mut V, _a_col: usize, scratch: &mut Scratch) where V::Scalar: From + Integer + Zero, { @@ -159,7 +159,7 @@ where let cols: usize = a.cols(); let size: usize = a.size(); - let steps: usize = k / log_base2k; + let steps: usize = k / basek; a.raw_mut().rotate_right(n * steps * cols); (0..cols).for_each(|i| { @@ -168,7 +168,7 @@ where }) }); - let k_rem: usize = k % log_base2k; + let k_rem: usize = k % basek; if k_rem != 0 { let (carry, _) = scratch.tmp_slice::(rsh_tmp_bytes::(n)); @@ -177,14 +177,14 @@ where std::ptr::write_bytes(carry.as_mut_ptr(), 0, n * size_of::()); } - let log_base2k_t = V::Scalar::from(log_base2k); + let basek_t = V::Scalar::from(basek); let shift = V::Scalar::from(V::Scalar::BITS as usize - k_rem); let k_rem_t = V::Scalar::from(k_rem); (0..cols).for_each(|i| { (steps..size).for_each(|j| { izip!(carry.iter_mut(), a.at_mut(i, j).iter_mut()).for_each(|(ci, xi)| { - *xi += *ci << log_base2k_t; + *xi += *ci << basek_t; *ci = (*xi << shift) >> shift; *xi = (*xi - *ci) >> k_rem_t; }); diff --git a/core/Cargo.toml b/core/Cargo.toml index a54bd5a..22b8f81 100644 --- a/core/Cargo.toml +++ b/core/Cargo.toml @@ -1,12 +1,12 @@ [package] -name = "rlwe" +name = "core" version = "0.1.0" edition = "2024" [dependencies] rug = {workspace = true} criterion = {workspace = true} -base2k = {path="../base2k"} +backend = {path="../backend"} sampling = {path="../sampling"} rand_distr = {workspace = true} itertools = {workspace = true} diff --git a/core/benches/external_product_glwe_fft64.rs b/core/benches/external_product_glwe_fft64.rs index 1739211..5e7e07c 100644 --- a/core/benches/external_product_glwe_fft64.rs +++ b/core/benches/external_product_glwe_fft64.rs @@ -1,4 +1,4 @@ -use base2k::{FFT64, Module, ScalarZnxAlloc, ScratchOwned}; +use backend::{Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, FFT64}; use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main}; use rlwe::{ elem::Infos, @@ -32,10 +32,10 @@ fn bench_external_product_glwe_fft64(c: &mut Criterion) { let rows: usize = (p.k_ct_in + p.basek - 1) / p.basek; let sigma: f64 = 3.2; - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_rlwe_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank); - let mut ct_rlwe_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank); - let pt_rgsw: base2k::ScalarZnx> = module.new_scalar_znx(1); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_rlwe_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_in, rank); + let mut ct_rlwe_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_out, rank); + let pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); let mut scratch = ScratchOwned::new( GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct_rgsw.size()) @@ -53,9 +53,9 @@ fn bench_external_product_glwe_fft64(c: &mut Criterion) { let mut source_xe = Source::new([0u8; 32]); let mut source_xa = Source::new([0u8; 32]); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_rgsw.encrypt_sk( @@ -127,9 +127,9 @@ fn bench_external_product_glwe_inplace_fft64(c: &mut Criterion) { let rows: usize = (p.k_ct + p.basek - 1) / p.basek; let sigma: f64 = 3.2; - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_glwe, rank); - let pt_rgsw: base2k::ScalarZnx> = module.new_scalar_znx(1); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_glwe, rank); + let pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); let mut scratch = ScratchOwned::new( GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct_rgsw.size()) @@ -141,9 +141,9 @@ fn bench_external_product_glwe_inplace_fft64(c: &mut Criterion) { let mut source_xe = Source::new([0u8; 32]); let mut source_xa = Source::new([0u8; 32]); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_rgsw.encrypt_sk( diff --git a/core/benches/keyswitch_glwe_fft64.rs b/core/benches/keyswitch_glwe_fft64.rs index 1c1b7f8..3dae4f8 100644 --- a/core/benches/keyswitch_glwe_fft64.rs +++ b/core/benches/keyswitch_glwe_fft64.rs @@ -1,4 +1,4 @@ -use base2k::{FFT64, Module, ScratchOwned}; +use backend::{FFT64, Module, ScratchOwned}; use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main}; use rlwe::{ elem::Infos, @@ -34,9 +34,9 @@ fn bench_keyswitch_glwe_fft64(c: &mut Criterion) { let rows: usize = (p.k_ct_in + p.basek - 1) / p.basek; let sigma: f64 = 3.2; - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_grlwe, rows, rank_in, rank_out); - let mut ct_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_rlwe_in, rank_in); - let mut ct_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_rlwe_out, rank_out); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_grlwe, rows, rank_in, rank_out); + let mut ct_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_rlwe_in, rank_in); + let mut ct_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_rlwe_out, rank_out); let mut scratch = ScratchOwned::new( GLWESwitchingKey::encrypt_sk_scratch_space(&module, rank_out, ksk.size()) @@ -55,14 +55,14 @@ fn bench_keyswitch_glwe_fft64(c: &mut Criterion) { let mut source_xe = Source::new([0u8; 32]); let mut source_xa = Source::new([0u8; 32]); - let mut sk_in: SecretKey> = SecretKey::new(&module, rank_in); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank_in); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank_out); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank_out); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -135,8 +135,8 @@ fn bench_keyswitch_glwe_inplace_fft64(c: &mut Criterion) { let rows: usize = (p.k_ct + p.basek - 1) / p.basek; let sigma: f64 = 3.2; - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank, rank); - let mut ct: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank, rank); + let mut ct: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); let mut scratch = ScratchOwned::new( GLWESwitchingKey::encrypt_sk_scratch_space(&module, rank, ksk.size()) @@ -148,14 +148,14 @@ fn bench_keyswitch_glwe_inplace_fft64(c: &mut Criterion) { let mut source_xe: Source = Source::new([0u8; 32]); let mut source_xa: Source = Source::new([0u8; 32]); - let mut sk_in: SecretKey> = SecretKey::new(&module, rank); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( diff --git a/core/src/automorphism.rs b/core/src/automorphism.rs index 8dca7ec..a120594 100644 --- a/core/src/automorphism.rs +++ b/core/src/automorphism.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftOps, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDftOps, ScalarZnxOps, ScalarZnxToRef, Scratch, VecZnx, VecZnxBigAlloc, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, ZnxZero, @@ -21,9 +21,9 @@ pub struct AutomorphismKey { } impl AutomorphismKey, FFT64> { - pub fn new(module: &Module, basek: usize, k: usize, rows: usize, rank: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rows: usize, rank: usize) -> Self { AutomorphismKey { - key: GLWESwitchingKey::new(module, basek, k, rows, rank, rank), + key: GLWESwitchingKey::alloc(module, basek, k, rows, rank, rank), p: 0, } } @@ -106,12 +106,12 @@ where } impl AutomorphismKey, FFT64> { - pub fn encrypt_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { - GGLWECiphertext::encrypt_sk_scratch_space(module, rank, size) + pub fn generate_from_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { + GGLWECiphertext::generate_from_sk_scratch_space(module, rank, size) } - pub fn encrypt_pk_scratch_space(module: &Module, rank: usize, pk_size: usize) -> usize { - GGLWECiphertext::encrypt_pk_scratch_space(module, rank, pk_size) + pub fn generate_from_pk_scratch_space(module: &Module, rank: usize, pk_size: usize) -> usize { + GGLWECiphertext::generate_from_pk_scratch_space(module, rank, pk_size) } pub fn keyswitch_scratch_space( @@ -170,7 +170,7 @@ impl AutomorphismKey where MatZnxDft: MatZnxDftToMut + MatZnxDftToRef, { - pub fn encrypt_sk( + pub fn generate_from_sk( &mut self, module: &Module, p: i64, @@ -228,7 +228,7 @@ where module: &Module, lhs: &AutomorphismKey, rhs: &AutomorphismKey, - scratch: &mut base2k::Scratch, + scratch: &mut Scratch, ) where MatZnxDft: MatZnxDftToRef, MatZnxDft: MatZnxDftToRef, @@ -341,7 +341,7 @@ where module: &Module, lhs: &AutomorphismKey, rhs: &GLWESwitchingKey, - scratch: &mut base2k::Scratch, + scratch: &mut Scratch, ) where MatZnxDft: MatZnxDftToRef, MatZnxDft: MatZnxDftToRef, @@ -352,12 +352,12 @@ where pub fn keyswitch_inplace( &mut self, module: &Module, - rhs: &GLWESwitchingKey, - scratch: &mut base2k::Scratch, + rhs: &AutomorphismKey, + scratch: &mut Scratch, ) where MatZnxDft: MatZnxDftToRef, { - self.key.keyswitch_inplace(module, &rhs, scratch); + self.key.keyswitch_inplace(module, &rhs.key, scratch); } pub fn external_product( diff --git a/core/src/elem.rs b/core/src/elem.rs index 66cb1d0..554b743 100644 --- a/core/src/elem.rs +++ b/core/src/elem.rs @@ -1,4 +1,4 @@ -use base2k::{Backend, Module, VecZnxDftToMut, VecZnxDftToRef, ZnxInfos}; +use backend::{Backend, Module, VecZnxDftToMut, VecZnxDftToRef, ZnxInfos}; use crate::utils::derive_size; diff --git a/core/src/gglwe_ciphertext.rs b/core/src/gglwe_ciphertext.rs index f8983c8..d5621c9 100644 --- a/core/src/gglwe_ciphertext.rs +++ b/core/src/gglwe_ciphertext.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftAlloc, MatZnxDftOps, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnxAlloc, VecZnxDftAlloc, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, ZnxInfos, ZnxZero, @@ -21,7 +21,7 @@ pub struct GGLWECiphertext { } impl GGLWECiphertext, B> { - pub fn new(module: &Module, basek: usize, k: usize, rows: usize, rank_in: usize, rank_out: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rows: usize, rank_in: usize, rank_out: usize) -> Self { Self { data: module.new_mat_znx_dft(rows, rank_in, rank_out + 1, derive_size(basek, k)), basek: basek, @@ -79,14 +79,14 @@ where } impl GGLWECiphertext, FFT64> { - pub fn encrypt_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { + pub fn generate_from_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { GLWECiphertext::encrypt_sk_scratch_space(module, size) + module.bytes_of_vec_znx(rank + 1, size) + module.bytes_of_vec_znx(1, size) + module.bytes_of_vec_znx_dft(rank + 1, size) } - pub fn encrypt_pk_scratch_space(_module: &Module, _rank: usize, _pk_size: usize) -> usize { + pub fn generate_from_pk_scratch_space(_module: &Module, _rank: usize, _pk_size: usize) -> usize { unimplemented!() } } @@ -95,7 +95,7 @@ impl GGLWECiphertext where MatZnxDft: MatZnxDftToMut + ZnxInfos, { - pub fn encrypt_sk( + pub fn generate_from_sk( &mut self, module: &Module, pt: &ScalarZnx, diff --git a/core/src/ggsw_ciphertext.rs b/core/src/ggsw_ciphertext.rs index 8955b7a..fdbc225 100644 --- a/core/src/ggsw_ciphertext.rs +++ b/core/src/ggsw_ciphertext.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftAlloc, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, VecZnxToMut, @@ -25,7 +25,7 @@ pub struct GGSWCiphertext { } impl GGSWCiphertext, B> { - pub fn new(module: &Module, basek: usize, k: usize, rows: usize, rank: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rows: usize, rank: usize) -> Self { Self { data: module.new_mat_znx_dft(rows, rank + 1, rank + 1, derive_size(basek, k)), basek: basek, diff --git a/core/src/glwe_ciphertext.rs b/core/src/glwe_ciphertext.rs index e319d21..155eca4 100644 --- a/core/src/glwe_ciphertext.rs +++ b/core/src/glwe_ciphertext.rs @@ -1,8 +1,8 @@ -use base2k::{ +use backend::{ AddNormal, Backend, FFT64, FillUniform, MatZnxDft, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToRef, Module, ScalarZnxAlloc, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScalarZnxDftToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBig, VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, - VecZnxToMut, VecZnxToRef, ZnxInfos, ZnxZero, + VecZnxToMut, VecZnxToRef, ZnxInfos, ZnxZero, copy_vec_znx_from, }; use sampling::source::Source; @@ -25,7 +25,7 @@ pub struct GLWECiphertext { } impl GLWECiphertext> { - pub fn new(module: &Module, basek: usize, k: usize, rank: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rank: usize) -> Self { Self { data: module.new_vec_znx(rank + 1, derive_size(basek, k)), basek, @@ -281,6 +281,21 @@ where self.encrypt_pk_private(module, None, pk, source_xu, source_xe, sigma, scratch); } + pub fn copy(&mut self, other: &GLWECiphertext) + where + VecZnx: VecZnxToRef, + { + copy_vec_znx_from(&mut self.data.to_mut(), &other.to_ref()); + self.k = other.k; + self.basek = other.basek; + } + + pub fn rsh(&mut self, k: usize, scratch: &mut Scratch) { + let basek: usize = self.basek(); + let mut self_mut: VecZnx<&mut [u8]> = self.data.to_mut(); + self_mut.rsh(basek, k, scratch); + } + pub fn automorphism( &mut self, module: &Module, @@ -311,6 +326,33 @@ where }) } + pub fn automorphism_add( + &mut self, + module: &Module, + lhs: &GLWECiphertext, + rhs: &AutomorphismKey, + scratch: &mut Scratch, + ) where + VecZnx: VecZnxToRef, + MatZnxDft: MatZnxDftToRef, + { + Self::keyswitch_private(self, true, rhs.p(), module, lhs, &rhs.key, scratch); + } + + pub fn automorphism_add_inplace( + &mut self, + module: &Module, + rhs: &AutomorphismKey, + scratch: &mut Scratch, + ) where + MatZnxDft: MatZnxDftToRef, + { + unsafe { + let self_ptr: *mut GLWECiphertext = self as *mut GLWECiphertext; + Self::keyswitch_private(self, true, rhs.p(), module, &*self_ptr, &rhs.key, scratch); + } + } + pub(crate) fn keyswitch_from_fourier( &mut self, module: &Module, @@ -379,6 +421,21 @@ where ) where VecZnx: VecZnxToRef, MatZnxDft: MatZnxDftToRef, + { + Self::keyswitch_private(self, false, 0, module, lhs, rhs, scratch); + } + + pub(crate) fn keyswitch_private( + &mut self, + add_self: bool, + apply_auto: i64, + module: &Module, + lhs: &GLWECiphertext, + rhs: &GLWESwitchingKey, + scratch: &mut Scratch, + ) where + VecZnx: VecZnxToRef, + MatZnxDft: MatZnxDftToRef, { let basek: usize = self.basek(); @@ -422,6 +479,13 @@ where module.vec_znx_big_add_small_inplace(&mut res_big, 0, lhs, 0); (0..cols_out).for_each(|i| { + if apply_auto != 0 { + module.vec_znx_big_automorphism_inplace(apply_auto, &mut res_big, i); + } + + if add_self { + module.vec_znx_big_add_small_inplace(&mut res_big, i, lhs, i); + } module.vec_znx_big_normalize(basek, self, i, &res_big, i, scratch1); }); } @@ -520,8 +584,8 @@ where } } - let log_base2k: usize = self.basek(); - let log_k: usize = self.k(); + let basek: usize = self.basek(); + let k: usize = self.k(); let size: usize = self.size(); let cols: usize = self.rank() + 1; @@ -535,7 +599,7 @@ where let (mut ci_dft, scratch_2) = scratch_1.tmp_vec_znx_dft(module, 1, size); // c[i] = uniform - self.data.fill_uniform(log_base2k, i, size, source_xa); + self.data.fill_uniform(basek, i, size, source_xa); // c[i] = norm(IDFT(DFT(c[i]) * DFT(s[i]))) module.vec_znx_dft(&mut ci_dft, 0, self, i); @@ -543,7 +607,7 @@ where let ci_big: VecZnxBig<&mut [u8], FFT64> = module.vec_znx_idft_consume(ci_dft); // use c[0] as buffer, which is overwritten later by the normalization step - module.vec_znx_big_normalize(log_base2k, self, 0, &ci_big, 0, scratch_2); + module.vec_znx_big_normalize(basek, self, 0, &ci_big, 0, scratch_2); // c0_tmp = -c[i] * s[i] (use c[0] as buffer) module.vec_znx_sub_ab_inplace(&mut c0_big, 0, self, 0); @@ -552,14 +616,14 @@ where if let Some((pt, col)) = pt { if i == col { module.vec_znx_add_inplace(self, i, pt, 0); - module.vec_znx_normalize_inplace(log_base2k, self, i, scratch_2); + module.vec_znx_normalize_inplace(basek, self, i, scratch_2); } } }); } // c[0] += e - c0_big.add_normal(log_base2k, 0, log_k, source_xe, sigma, sigma * SIX_SIGMA); + c0_big.add_normal(basek, 0, k, source_xe, sigma, sigma * SIX_SIGMA); // c[0] += m if col = 0 if let Some((pt, col)) = pt { @@ -569,7 +633,7 @@ where } // c[0] = norm(c[0]) - module.vec_znx_normalize(log_base2k, self, 0, &c0_big, 0, scratch_1); + module.vec_znx_normalize(basek, self, 0, &c0_big, 0, scratch_1); } pub(crate) fn encrypt_pk_private( @@ -597,7 +661,7 @@ where } } - let log_base2k: usize = pk.basek(); + let basek: usize = pk.basek(); let size_pk: usize = pk.size(); let cols: usize = self.rank() + 1; @@ -629,7 +693,7 @@ where let mut ci_big = module.vec_znx_idft_consume(ci_dft); // ci_big = u * pk[i] + e - ci_big.add_normal(log_base2k, 0, pk.k(), source_xe, sigma, sigma * SIX_SIGMA); + ci_big.add_normal(basek, 0, pk.k(), source_xe, sigma, sigma * SIX_SIGMA); // ci_big = u * pk[i] + e + m (if col = i) if let Some((pt, col)) = pt { @@ -639,7 +703,7 @@ where } // ct[i] = norm(ci_big) - module.vec_znx_big_normalize(log_base2k, self, i, &ci_big, 0, scratch_2); + module.vec_znx_big_normalize(basek, self, i, &ci_big, 0, scratch_2); }); } } diff --git a/core/src/glwe_ciphertext_fourier.rs b/core/src/glwe_ciphertext_fourier.rs index 135a2dd..20b4f72 100644 --- a/core/src/glwe_ciphertext_fourier.rs +++ b/core/src/glwe_ciphertext_fourier.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToRef, Module, ScalarZnxDft, ScalarZnxDftOps, ScalarZnxDftToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBig, VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxToMut, VecZnxToRef, ZnxZero, @@ -17,7 +17,7 @@ pub struct GLWECiphertextFourier { } impl GLWECiphertextFourier, B> { - pub fn new(module: &Module, basek: usize, k: usize, rank: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rank: usize) -> Self { Self { data: module.new_vec_znx_dft(rank + 1, derive_size(basek, k)), basek: basek, diff --git a/core/src/glwe_plaintext.rs b/core/src/glwe_plaintext.rs index 4900fa0..ed4826d 100644 --- a/core/src/glwe_plaintext.rs +++ b/core/src/glwe_plaintext.rs @@ -1,4 +1,4 @@ -use base2k::{Backend, Module, VecZnx, VecZnxAlloc, VecZnxToMut, VecZnxToRef}; +use backend::{Backend, Module, VecZnx, VecZnxAlloc, VecZnxToMut, VecZnxToRef}; use crate::{elem::Infos, utils::derive_size}; @@ -43,7 +43,7 @@ where } impl GLWEPlaintext> { - pub fn new(module: &Module, basek: usize, k: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize) -> Self { Self { data: module.new_vec_znx(1, derive_size(basek, k)), basek: basek, diff --git a/core/src/keys.rs b/core/src/keys.rs index 8a4d5e1..3b0af56 100644 --- a/core/src/keys.rs +++ b/core/src/keys.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScalarZnxDftToMut, ScalarZnxDftToRef, ScalarZnxToMut, ScalarZnxToRef, ScratchOwned, VecZnxDft, VecZnxDftToMut, VecZnxDftToRef, ZnxInfos, ZnxZero, @@ -21,7 +21,7 @@ pub struct SecretKey { } impl SecretKey> { - pub fn new(module: &Module, rank: usize) -> Self { + pub fn alloc(module: &Module, rank: usize) -> Self { Self { data: module.new_scalar_znx(rank), dist: SecretDistribution::NONE, @@ -105,7 +105,7 @@ impl SecretKeyFourier { } impl SecretKeyFourier, B> { - pub fn new(module: &Module, rank: usize) -> Self { + pub fn alloc(module: &Module, rank: usize) -> Self { Self { data: module.new_scalar_znx_dft(rank), dist: SecretDistribution::NONE, @@ -114,7 +114,7 @@ impl SecretKeyFourier, B> { pub fn dft(&mut self, module: &Module, sk: &SecretKey) where - SecretKeyFourier, B>: ScalarZnxDftToMut, + SecretKeyFourier, B>: ScalarZnxDftToMut, SecretKey: ScalarZnxToRef, { #[cfg(debug_assertions)] @@ -160,9 +160,9 @@ pub struct GLWEPublicKey { } impl GLWEPublicKey, B> { - pub fn new(module: &Module, log_base2k: usize, log_k: usize, rank: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rank: usize) -> Self { Self { - data: GLWECiphertextFourier::new(module, log_base2k, log_k, rank), + data: GLWECiphertextFourier::alloc(module, basek, k, rank), dist: SecretDistribution::NONE, } } @@ -209,7 +209,7 @@ where } impl GLWEPublicKey { - pub fn generate( + pub fn generate_from_sk( &mut self, module: &Module, sk_dft: &SecretKeyFourier, diff --git a/core/src/keyswitch_key.rs b/core/src/keyswitch_key.rs index cade469..a4ace4a 100644 --- a/core/src/keyswitch_key.rs +++ b/core/src/keyswitch_key.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftOps, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnxDftAlloc, VecZnxDftToMut, VecZnxDftToRef, ZnxZero, }; @@ -15,8 +15,8 @@ use crate::{ pub struct GLWESwitchingKey(pub(crate) GGLWECiphertext); impl GLWESwitchingKey, FFT64> { - pub fn new(module: &Module, basek: usize, k: usize, rows: usize, rank_in: usize, rank_out: usize) -> Self { - GLWESwitchingKey(GGLWECiphertext::new( + pub fn alloc(module: &Module, basek: usize, k: usize, rows: usize, rank_in: usize, rank_out: usize) -> Self { + GLWESwitchingKey(GGLWECiphertext::alloc( module, basek, k, rows, rank_in, rank_out, )) } @@ -96,11 +96,11 @@ where impl GLWESwitchingKey, FFT64> { pub fn encrypt_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { - GGLWECiphertext::encrypt_sk_scratch_space(module, rank, size) + GGLWECiphertext::generate_from_sk_scratch_space(module, rank, size) } pub fn encrypt_pk_scratch_space(module: &Module, rank: usize, pk_size: usize) -> usize { - GGLWECiphertext::encrypt_pk_scratch_space(module, rank, pk_size) + GGLWECiphertext::generate_from_pk_scratch_space(module, rank, pk_size) } pub fn keyswitch_scratch_space( @@ -164,7 +164,7 @@ where ScalarZnx: ScalarZnxToRef, ScalarZnxDft: ScalarZnxDftToRef, { - self.0.encrypt_sk( + self.0.generate_from_sk( module, &sk_in.data, sk_out_dft, @@ -180,7 +180,7 @@ where module: &Module, lhs: &GLWESwitchingKey, rhs: &GLWESwitchingKey, - scratch: &mut base2k::Scratch, + scratch: &mut Scratch, ) where MatZnxDft: MatZnxDftToRef, MatZnxDft: MatZnxDftToRef, @@ -247,7 +247,7 @@ where &mut self, module: &Module, rhs: &GLWESwitchingKey, - scratch: &mut base2k::Scratch, + scratch: &mut Scratch, ) where MatZnxDft: MatZnxDftToRef, { diff --git a/core/src/lib.rs b/core/src/lib.rs index 74ed7ef..249ad94 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -10,6 +10,7 @@ pub mod keyswitch_key; pub mod tensor_key; #[cfg(test)] mod test_fft64; +pub mod trace; mod utils; pub(crate) const SIX_SIGMA: f64 = 6.0; diff --git a/core/src/tensor_key.rs b/core/src/tensor_key.rs index 158274d..ee31c8d 100644 --- a/core/src/tensor_key.rs +++ b/core/src/tensor_key.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScalarZnxDftToRef, Scratch, VecZnxDftOps, VecZnxDftToRef, }; @@ -15,11 +15,11 @@ pub struct TensorKey { } impl TensorKey, FFT64> { - pub fn new(module: &Module, basek: usize, k: usize, rows: usize, rank: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rows: usize, rank: usize) -> Self { let mut keys: Vec, FFT64>> = Vec::new(); let pairs: usize = ((rank + 1) * rank) >> 1; (0..pairs).for_each(|_| { - keys.push(GLWESwitchingKey::new(module, basek, k, rows, 1, rank)); + keys.push(GLWESwitchingKey::alloc(module, basek, k, rows, 1, rank)); }); Self { keys: keys } } diff --git a/core/src/test_fft64/automorphism_key.rs b/core/src/test_fft64/automorphism_key.rs index ea63550..d469660 100644 --- a/core/src/test_fft64/automorphism_key.rs +++ b/core/src/test_fft64/automorphism_key.rs @@ -1,4 +1,4 @@ -use base2k::{FFT64, Module, ScalarZnxOps, ScratchOwned, Stats, VecZnxOps}; +use backend::{FFT64, Module, ScalarZnxOps, ScratchOwned, Stats, VecZnxOps}; use sampling::source::Source; use crate::{ @@ -30,16 +30,16 @@ fn test_automorphism(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk: usize, let module: Module = Module::::new(1 << log_n); let rows = (k_ksk + basek - 1) / basek; - let mut auto_key_in: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_ksk, rows, rank); - let mut auto_key_out: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_ksk, rows, rank); - let mut auto_key_apply: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_ksk, rows, rank); + let mut auto_key_in: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, rank); + let mut auto_key_out: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, rank); + let mut auto_key_apply: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, rank); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); let mut source_xa: Source = Source::new([0u8; 32]); let mut scratch: ScratchOwned = ScratchOwned::new( - AutomorphismKey::encrypt_sk_scratch_space(&module, rank, auto_key_in.size()) + AutomorphismKey::generate_from_sk_scratch_space(&module, rank, auto_key_in.size()) | GLWECiphertextFourier::decrypt_scratch_space(&module, auto_key_out.size()) | AutomorphismKey::automorphism_scratch_space( &module, @@ -50,14 +50,14 @@ fn test_automorphism(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk: usize, ), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); // gglwe_{s1}(s0) = s0 -> s1 - auto_key_in.encrypt_sk( + auto_key_in.generate_from_sk( &module, p0, &sk, @@ -68,7 +68,7 @@ fn test_automorphism(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk: usize, ); // gglwe_{s2}(s1) -> s1 -> s2 - auto_key_apply.encrypt_sk( + auto_key_apply.generate_from_sk( &module, p1, &sk, @@ -81,16 +81,16 @@ fn test_automorphism(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk: usize, // gglwe_{s1}(s0) (x) gglwe_{s2}(s1) = gglwe_{s2}(s0) auto_key_out.automorphism(&module, &auto_key_in, &auto_key_apply, scratch.borrow()); - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ksk, rank); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ksk); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ksk); - let mut sk_auto: SecretKey> = SecretKey::new(&module, rank); + let mut sk_auto: SecretKey> = SecretKey::alloc(&module, rank); sk_auto.fill_zero(); // Necessary to avoid panic of unfilled sk (0..rank).for_each(|i| { module.scalar_znx_automorphism(module.galois_element_inv(p0 * p1), &mut sk_auto, i, &sk, i); }); - let mut sk_auto_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_auto_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_auto_dft.dft(&module, &sk_auto); (0..auto_key_out.rank_in()).for_each(|col_i| { @@ -128,27 +128,27 @@ fn test_automorphism_inplace(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk let module: Module = Module::::new(1 << log_n); let rows = (k_ksk + basek - 1) / basek; - let mut auto_key: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_ksk, rows, rank); - let mut auto_key_apply: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_ksk, rows, rank); + let mut auto_key: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, rank); + let mut auto_key_apply: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, rank); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); let mut source_xa: Source = Source::new([0u8; 32]); let mut scratch: ScratchOwned = ScratchOwned::new( - AutomorphismKey::encrypt_sk_scratch_space(&module, rank, auto_key.size()) + AutomorphismKey::generate_from_sk_scratch_space(&module, rank, auto_key.size()) | GLWECiphertextFourier::decrypt_scratch_space(&module, auto_key.size()) | AutomorphismKey::automorphism_inplace_scratch_space(&module, auto_key.size(), auto_key_apply.size(), rank), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); // gglwe_{s1}(s0) = s0 -> s1 - auto_key.encrypt_sk( + auto_key.generate_from_sk( &module, p0, &sk, @@ -159,7 +159,7 @@ fn test_automorphism_inplace(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk ); // gglwe_{s2}(s1) -> s1 -> s2 - auto_key_apply.encrypt_sk( + auto_key_apply.generate_from_sk( &module, p1, &sk, @@ -172,16 +172,16 @@ fn test_automorphism_inplace(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk // gglwe_{s1}(s0) (x) gglwe_{s2}(s1) = gglwe_{s2}(s0) auto_key.automorphism_inplace(&module, &auto_key_apply, scratch.borrow()); - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ksk, rank); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ksk); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ksk); - let mut sk_auto: SecretKey> = SecretKey::new(&module, rank); + let mut sk_auto: SecretKey> = SecretKey::alloc(&module, rank); sk_auto.fill_zero(); // Necessary to avoid panic of unfilled sk (0..rank).for_each(|i| { module.scalar_znx_automorphism(module.galois_element_inv(p0 * p1), &mut sk_auto, i, &sk, i); }); - let mut sk_auto_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_auto_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_auto_dft.dft(&module, &sk_auto); (0..auto_key.rank_in()).for_each(|col_i| { diff --git a/core/src/test_fft64/gglwe.rs b/core/src/test_fft64/gglwe.rs index d497dbf..5324a02 100644 --- a/core/src/test_fft64/gglwe.rs +++ b/core/src/test_fft64/gglwe.rs @@ -1,4 +1,4 @@ -use base2k::{FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxToMut, ScratchOwned, Stats, VecZnxOps, ZnxViewMut}; +use backend::{FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxToMut, ScratchOwned, Stats, VecZnxOps, ZnxViewMut}; use sampling::source::Source; use crate::{ @@ -76,8 +76,8 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, rank_in let module: Module = Module::::new(1 << log_n); let rows = (k_ksk + basek - 1) / basek; - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_in, rank_out); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ksk); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_in, rank_out); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ksk); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -88,16 +88,16 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, rank_in | GLWECiphertextFourier::decrypt_scratch_space(&module, ksk.size()), ); - let mut sk_in: SecretKey> = SecretKey::new(&module, rank_in); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank_in); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank_out); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank_out); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -110,7 +110,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, rank_in scratch.borrow(), ); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ksk, rank_out); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank_out); (0..ksk.rank_in()).for_each(|col_i| { (0..ksk.rows()).for_each(|row_i| { @@ -136,11 +136,11 @@ fn test_key_switch( let rows = (k_ksk + basek - 1) / basek; let mut ct_gglwe_s0s1: GLWESwitchingKey, FFT64> = - GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_in_s0s1, rank_out_s0s1); + GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_in_s0s1, rank_out_s0s1); let mut ct_gglwe_s1s2: GLWESwitchingKey, FFT64> = - GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_out_s0s1, rank_out_s1s2); + GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_out_s0s1, rank_out_s1s2); let mut ct_gglwe_s0s2: GLWESwitchingKey, FFT64> = - GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_in_s0s1, rank_out_s1s2); + GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_in_s0s1, rank_out_s1s2); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -159,22 +159,22 @@ fn test_key_switch( ), ); - let mut sk0: SecretKey> = SecretKey::new(&module, rank_in_s0s1); + let mut sk0: SecretKey> = SecretKey::alloc(&module, rank_in_s0s1); sk0.fill_ternary_prob(0.5, &mut source_xs); - let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in_s0s1); + let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in_s0s1); sk0_dft.dft(&module, &sk0); - let mut sk1: SecretKey> = SecretKey::new(&module, rank_out_s0s1); + let mut sk1: SecretKey> = SecretKey::alloc(&module, rank_out_s0s1); sk1.fill_ternary_prob(0.5, &mut source_xs); - let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out_s0s1); + let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out_s0s1); sk1_dft.dft(&module, &sk1); - let mut sk2: SecretKey> = SecretKey::new(&module, rank_out_s1s2); + let mut sk2: SecretKey> = SecretKey::alloc(&module, rank_out_s1s2); sk2.fill_ternary_prob(0.5, &mut source_xs); - let mut sk2_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out_s1s2); + let mut sk2_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out_s1s2); sk2_dft.dft(&module, &sk2); // gglwe_{s1}(s0) = s0 -> s1 @@ -202,8 +202,8 @@ fn test_key_switch( // gglwe_{s1}(s0) (x) gglwe_{s2}(s1) = gglwe_{s2}(s0) ct_gglwe_s0s2.keyswitch(&module, &ct_gglwe_s0s1, &ct_gglwe_s1s2, scratch.borrow()); - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ksk, rank_out_s1s2); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ksk); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank_out_s1s2); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ksk); (0..ct_gglwe_s0s2.rank_in()).for_each(|col_i| { (0..ct_gglwe_s0s2.rows()).for_each(|row_i| { @@ -240,9 +240,9 @@ fn test_key_switch_inplace(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, let rows: usize = (k_ksk + basek - 1) / basek; let mut ct_gglwe_s0s1: GLWESwitchingKey, FFT64> = - GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_in_s0s1, rank_out_s0s1); + GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_in_s0s1, rank_out_s0s1); let mut ct_gglwe_s1s2: GLWESwitchingKey, FFT64> = - GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_out_s0s1, rank_out_s0s1); + GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_out_s0s1, rank_out_s0s1); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -259,22 +259,22 @@ fn test_key_switch_inplace(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, ), ); - let mut sk0: SecretKey> = SecretKey::new(&module, rank_in_s0s1); + let mut sk0: SecretKey> = SecretKey::alloc(&module, rank_in_s0s1); sk0.fill_ternary_prob(0.5, &mut source_xs); - let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in_s0s1); + let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in_s0s1); sk0_dft.dft(&module, &sk0); - let mut sk1: SecretKey> = SecretKey::new(&module, rank_out_s0s1); + let mut sk1: SecretKey> = SecretKey::alloc(&module, rank_out_s0s1); sk1.fill_ternary_prob(0.5, &mut source_xs); - let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out_s0s1); + let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out_s0s1); sk1_dft.dft(&module, &sk1); - let mut sk2: SecretKey> = SecretKey::new(&module, rank_out_s0s1); + let mut sk2: SecretKey> = SecretKey::alloc(&module, rank_out_s0s1); sk2.fill_ternary_prob(0.5, &mut source_xs); - let mut sk2_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out_s0s1); + let mut sk2_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out_s0s1); sk2_dft.dft(&module, &sk2); // gglwe_{s1}(s0) = s0 -> s1 @@ -304,8 +304,8 @@ fn test_key_switch_inplace(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, let ct_gglwe_s0s2: GLWESwitchingKey, FFT64> = ct_gglwe_s0s1; - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ksk, rank_out_s0s1); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ksk); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank_out_s0s1); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ksk); (0..ct_gglwe_s0s2.rank_in()).for_each(|col_i| { (0..ct_gglwe_s0s2.rows()).for_each(|row_i| { @@ -342,9 +342,9 @@ fn test_external_product(log_n: usize, basek: usize, k: usize, sigma: f64, rank_ let rows: usize = (k + basek - 1) / basek; - let mut ct_gglwe_in: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k, rows, rank_in, rank_out); - let mut ct_gglwe_out: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k, rows, rank_in, rank_out); - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank_out); + let mut ct_gglwe_in: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k, rows, rank_in, rank_out); + let mut ct_gglwe_out: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k, rows, rank_in, rank_out); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank_out); let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); @@ -369,16 +369,16 @@ fn test_external_product(log_n: usize, basek: usize, k: usize, sigma: f64, rank_ pt_rgsw.to_mut().raw_mut()[r] = 1; // X^{r} - let mut sk_in: SecretKey> = SecretKey::new(&module, rank_in); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank_in); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank_out); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank_out); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); // gglwe_{s1}(s0) = s0 -> s1 @@ -418,8 +418,8 @@ fn test_external_product(log_n: usize, basek: usize, k: usize, sigma: f64, rank_ | GGSWCiphertext::encrypt_sk_scratch_space(&module, rank_out, ct_rgsw.size()), ); - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank_out); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank_out); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); (0..rank_in).for_each(|i| { module.vec_znx_rotate_inplace(r as i64, &mut sk_in.data, i); // * X^{r} @@ -469,8 +469,8 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k: usize, sigma: f6 let rows: usize = (k + basek - 1) / basek; - let mut ct_gglwe: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k, rows, rank_in, rank_out); - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank_out); + let mut ct_gglwe: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k, rows, rank_in, rank_out); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank_out); let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); @@ -489,16 +489,16 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k: usize, sigma: f6 pt_rgsw.to_mut().raw_mut()[r] = 1; // X^{r} - let mut sk_in: SecretKey> = SecretKey::new(&module, rank_in); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank_in); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank_out); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank_out); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); // gglwe_{s1}(s0) = s0 -> s1 @@ -525,8 +525,8 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k: usize, sigma: f6 // gglwe_(m) (x) RGSW_(X^k) = gglwe_(m * X^k) ct_gglwe.external_product_inplace(&module, &ct_rgsw, scratch.borrow()); - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank_out); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank_out); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); (0..rank_in).for_each(|i| { module.vec_znx_rotate_inplace(r as i64, &mut sk_in.data, i); // * X^{r} diff --git a/core/src/test_fft64/ggsw.rs b/core/src/test_fft64/ggsw.rs index f02bd87..45855a5 100644 --- a/core/src/test_fft64/ggsw.rs +++ b/core/src/test_fft64/ggsw.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxDftOps, ScalarZnxOps, ScratchOwned, Stats, VecZnxBig, VecZnxBigAlloc, VecZnxBigOps, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxOps, VecZnxToMut, ZnxViewMut, ZnxZero, }; @@ -78,9 +78,9 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ggsw: usize, sigma: f64, rank: let rows: usize = (k_ggsw + basek - 1) / basek; - let mut ct: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ggsw); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ggsw); + let mut ct: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ggsw); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ggsw); let mut pt_scalar: ScalarZnx> = module.new_scalar_znx(1); let mut source_xs: Source = Source::new([0u8; 32]); @@ -94,10 +94,10 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ggsw: usize, sigma: f64, rank: | GLWECiphertextFourier::decrypt_scratch_space(&module, ct.size()), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct.encrypt_sk( @@ -110,7 +110,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ggsw: usize, sigma: f64, rank: scratch.borrow(), ); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ggsw, rank); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ggsw, rank); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct.size()); @@ -144,12 +144,12 @@ fn test_keyswitch(log_n: usize, basek: usize, k: usize, rank: usize, sigma: f64) let module: Module = Module::::new(1 << log_n); let rows: usize = (k + basek - 1) / basek; - let mut ct_in: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank); - let mut ct_out: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank); - let mut tsk: TensorKey, FFT64> = TensorKey::new(&module, basek, k, rows, rank); - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k, rows, rank, rank); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct_in: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank); + let mut ct_out: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank); + let mut tsk: TensorKey, FFT64> = TensorKey::alloc(&module, basek, k, rows, rank); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k, rows, rank, rank); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); let mut pt_scalar: ScalarZnx> = module.new_scalar_znx(1); let mut source_xs: Source = Source::new([0u8; 32]); @@ -173,16 +173,16 @@ fn test_keyswitch(log_n: usize, basek: usize, k: usize, rank: usize, sigma: f64) let var_xs: f64 = 0.5; - let mut sk_in: SecretKey> = SecretKey::new(&module, rank); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank); sk_in.fill_ternary_prob(var_xs, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank); sk_out.fill_ternary_prob(var_xs, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -217,7 +217,7 @@ fn test_keyswitch(log_n: usize, basek: usize, k: usize, rank: usize, sigma: f64) ct_out.keyswitch(&module, &ct_in, &ksk, &tsk, scratch.borrow()); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct_out.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct_out.size()); @@ -271,11 +271,11 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k: usize, rank: usize, sig let module: Module = Module::::new(1 << log_n); let rows: usize = (k + basek - 1) / basek; - let mut ct: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank); - let mut tsk: TensorKey, FFT64> = TensorKey::new(&module, basek, k, rows, rank); - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k, rows, rank, rank); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank); + let mut tsk: TensorKey, FFT64> = TensorKey::alloc(&module, basek, k, rows, rank); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k, rows, rank, rank); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); let mut pt_scalar: ScalarZnx> = module.new_scalar_znx(1); let mut source_xs: Source = Source::new([0u8; 32]); @@ -292,16 +292,16 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k: usize, rank: usize, sig let var_xs: f64 = 0.5; - let mut sk_in: SecretKey> = SecretKey::new(&module, rank); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank); sk_in.fill_ternary_prob(var_xs, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank); sk_out.fill_ternary_prob(var_xs, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -336,7 +336,7 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k: usize, rank: usize, sig ct.keyswitch_inplace(&module, &ksk, &tsk, scratch.borrow()); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct.size()); @@ -439,12 +439,12 @@ fn test_automorphism(p: i64, log_n: usize, basek: usize, k: usize, rank: usize, let module: Module = Module::::new(1 << log_n); let rows: usize = (k + basek - 1) / basek; - let mut ct_in: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank); - let mut ct_out: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank); - let mut tensor_key: TensorKey, FFT64> = TensorKey::new(&module, basek, k, rows, rank); - let mut auto_key: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k, rows, rank); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct_in: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank); + let mut ct_out: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank); + let mut tensor_key: TensorKey, FFT64> = TensorKey::alloc(&module, basek, k, rows, rank); + let mut auto_key: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k, rows, rank); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); let mut pt_scalar: ScalarZnx> = module.new_scalar_znx(1); let mut source_xs: Source = Source::new([0u8; 32]); @@ -454,7 +454,7 @@ fn test_automorphism(p: i64, log_n: usize, basek: usize, k: usize, rank: usize, let mut scratch: ScratchOwned = ScratchOwned::new( GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct_in.size()) | GLWECiphertextFourier::decrypt_scratch_space(&module, ct_out.size()) - | AutomorphismKey::encrypt_sk_scratch_space(&module, rank, auto_key.size()) + | AutomorphismKey::generate_from_sk_scratch_space(&module, rank, auto_key.size()) | TensorKey::encrypt_sk_scratch_space(&module, rank, tensor_key.size()) | GGSWCiphertext::automorphism_scratch_space( &module, @@ -468,13 +468,13 @@ fn test_automorphism(p: i64, log_n: usize, basek: usize, k: usize, rank: usize, let var_xs: f64 = 0.5; - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(var_xs, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); - auto_key.encrypt_sk( + auto_key.generate_from_sk( &module, p, &sk, @@ -508,7 +508,7 @@ fn test_automorphism(p: i64, log_n: usize, basek: usize, k: usize, rank: usize, module.scalar_znx_automorphism_inplace(p, &mut pt_scalar, 0); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct_out.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct_out.size()); @@ -560,11 +560,11 @@ fn test_automorphism_inplace(p: i64, log_n: usize, basek: usize, k: usize, rank: let module: Module = Module::::new(1 << log_n); let rows: usize = (k + basek - 1) / basek; - let mut ct: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank); - let mut tensor_key: TensorKey, FFT64> = TensorKey::new(&module, basek, k, rows, rank); - let mut auto_key: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k, rows, rank); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank); + let mut tensor_key: TensorKey, FFT64> = TensorKey::alloc(&module, basek, k, rows, rank); + let mut auto_key: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k, rows, rank); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); let mut pt_scalar: ScalarZnx> = module.new_scalar_znx(1); let mut source_xs: Source = Source::new([0u8; 32]); @@ -574,20 +574,20 @@ fn test_automorphism_inplace(p: i64, log_n: usize, basek: usize, k: usize, rank: let mut scratch: ScratchOwned = ScratchOwned::new( GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct.size()) | GLWECiphertextFourier::decrypt_scratch_space(&module, ct.size()) - | AutomorphismKey::encrypt_sk_scratch_space(&module, rank, auto_key.size()) + | AutomorphismKey::generate_from_sk_scratch_space(&module, rank, auto_key.size()) | TensorKey::encrypt_sk_scratch_space(&module, rank, tensor_key.size()) | GGSWCiphertext::automorphism_inplace_scratch_space(&module, ct.size(), auto_key.size(), tensor_key.size(), rank), ); let var_xs: f64 = 0.5; - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(var_xs, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); - auto_key.encrypt_sk( + auto_key.generate_from_sk( &module, p, &sk, @@ -621,7 +621,7 @@ fn test_automorphism_inplace(p: i64, log_n: usize, basek: usize, k: usize, rank: module.scalar_znx_automorphism_inplace(p, &mut pt_scalar, 0); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct.size()); @@ -674,9 +674,9 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, rank: usize, let rows: usize = (k_ggsw + basek - 1) / basek; - let mut ct_ggsw_rhs: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_ggsw_lhs_in: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_ggsw_lhs_out: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); + let mut ct_ggsw_rhs: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_ggsw_lhs_in: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_ggsw_lhs_out: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); let mut pt_ggsw_lhs: ScalarZnx> = module.new_scalar_znx(1); let mut pt_ggsw_rhs: ScalarZnx> = module.new_scalar_znx(1); @@ -702,10 +702,10 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, rank: usize, ), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_ggsw_rhs.encrypt_sk( @@ -730,11 +730,11 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, rank: usize, ct_ggsw_lhs_out.external_product(&module, &ct_ggsw_lhs_in, &ct_ggsw_rhs, scratch.borrow()); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ggsw, rank); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ggsw); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ggsw, rank); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ggsw); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct_ggsw_lhs_out.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct_ggsw_lhs_out.size()); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ggsw); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ggsw); module.vec_znx_rotate_inplace(k as i64, &mut pt_ggsw_lhs, 0); @@ -793,8 +793,8 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, rank let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ggsw + basek - 1) / basek; - let mut ct_ggsw_rhs: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_ggsw_lhs: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); + let mut ct_ggsw_rhs: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_ggsw_lhs: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); let mut pt_ggsw_lhs: ScalarZnx> = module.new_scalar_znx(1); let mut pt_ggsw_rhs: ScalarZnx> = module.new_scalar_znx(1); @@ -815,10 +815,10 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, rank | GGSWCiphertext::external_product_inplace_scratch_space(&module, ct_ggsw_lhs.size(), ct_ggsw_rhs.size(), rank), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_ggsw_rhs.encrypt_sk( @@ -843,11 +843,11 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, rank ct_ggsw_lhs.external_product_inplace(&module, &ct_ggsw_rhs, scratch.borrow()); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ggsw, rank); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ggsw); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ggsw, rank); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ggsw); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct_ggsw_lhs.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct_ggsw_lhs.size()); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ggsw); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ggsw); module.vec_znx_rotate_inplace(k as i64, &mut pt_ggsw_lhs, 0); diff --git a/core/src/test_fft64/glwe.rs b/core/src/test_fft64/glwe.rs index 0f7fcc1..91bb300 100644 --- a/core/src/test_fft64/glwe.rs +++ b/core/src/test_fft64/glwe.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Decoding, Encoding, FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, VecZnxToMut, ZnxViewMut, ZnxZero, }; @@ -94,8 +94,8 @@ fn automorphism() { fn test_encrypt_sk(log_n: usize, basek: usize, k_ct: usize, k_pt: usize, sigma: f64, rank: usize) { let module: Module = Module::::new(1 << log_n); - let mut ct: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_pt); + let mut ct: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_pt); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -105,10 +105,10 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ct: usize, k_pt: usize, sigma: GLWECiphertext::encrypt_sk_scratch_space(&module, ct.size()) | GLWECiphertext::decrypt_scratch_space(&module, ct.size()), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); let mut data_want: Vec = vec![0i64; module.n()]; @@ -154,18 +154,18 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ct: usize, k_pt: usize, sigma: fn test_encrypt_zero_sk(log_n: usize, basek: usize, k_ct: usize, sigma: f64, rank: usize) { let module: Module = Module::::new(1 << log_n); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([1u8; 32]); let mut source_xa: Source = Source::new([0u8; 32]); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); - let mut ct_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct, rank); + let mut ct_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct, rank); let mut scratch: ScratchOwned = ScratchOwned::new( GLWECiphertextFourier::decrypt_scratch_space(&module, ct_dft.size()) @@ -188,21 +188,21 @@ fn test_encrypt_zero_sk(log_n: usize, basek: usize, k_ct: usize, sigma: f64, ran fn test_encrypt_pk(log_n: usize, basek: usize, k_ct: usize, k_pk: usize, sigma: f64, rank: usize) { let module: Module = Module::::new(1 << log_n); - let mut ct: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut ct: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); let mut source_xa: Source = Source::new([0u8; 32]); let mut source_xu: Source = Source::new([0u8; 32]); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); - let mut pk: GLWEPublicKey, FFT64> = GLWEPublicKey::new(&module, basek, k_pk, rank); - pk.generate(&module, &sk_dft, &mut source_xa, &mut source_xe, sigma); + let mut pk: GLWEPublicKey, FFT64> = GLWEPublicKey::alloc(&module, basek, k_pk, rank); + pk.generate_from_sk(&module, &sk_dft, &mut source_xa, &mut source_xe, sigma); let mut scratch: ScratchOwned = ScratchOwned::new( GLWECiphertext::encrypt_sk_scratch_space(&module, ct.size()) @@ -228,7 +228,7 @@ fn test_encrypt_pk(log_n: usize, basek: usize, k_ct: usize, k_pk: usize, sigma: scratch.borrow(), ); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); ct.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); @@ -258,11 +258,11 @@ fn test_keyswitch( let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct_in + basek - 1) / basek; - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_keyswitch, rows, rank_in, rank_out); - let mut ct_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank_in); - let mut ct_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank_out); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_in); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_out); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_keyswitch, rows, rank_in, rank_out); + let mut ct_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_in, rank_in); + let mut ct_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_out, rank_out); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_in); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_out); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -287,16 +287,16 @@ fn test_keyswitch( ), ); - let mut sk_in: SecretKey> = SecretKey::new(&module, rank_in); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank_in); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank_out); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank_out); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -351,10 +351,10 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct + basek - 1) / basek; - let mut ct_grlwe: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank, rank); - let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut ct_grlwe: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank, rank); + let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -372,16 +372,16 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, | GLWECiphertext::keyswitch_inplace_scratch_space(&module, ct_rlwe.size(), rank, ct_grlwe.size()), ); - let mut sk0: SecretKey> = SecretKey::new(&module, rank); + let mut sk0: SecretKey> = SecretKey::alloc(&module, rank); sk0.fill_ternary_prob(0.5, &mut source_xs); - let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk0_dft.dft(&module, &sk0); - let mut sk1: SecretKey> = SecretKey::new(&module, rank); + let mut sk1: SecretKey> = SecretKey::alloc(&module, rank); sk1.fill_ternary_prob(0.5, &mut source_xs); - let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk1_dft.dft(&module, &sk1); ct_grlwe.encrypt_sk( @@ -445,11 +445,11 @@ fn test_automorphism( let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct_in + basek - 1) / basek; - let mut autokey: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_autokey, rows, rank); - let mut ct_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank); - let mut ct_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_in); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_out); + let mut autokey: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_autokey, rows, rank); + let mut ct_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_in, rank); + let mut ct_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_out, rank); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_in); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_out); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -466,13 +466,13 @@ fn test_automorphism( | GLWECiphertext::automorphism_scratch_space(&module, ct_out.size(), rank, ct_in.size(), autokey.size()), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); - autokey.encrypt_sk( + autokey.generate_from_sk( &module, p, &sk, @@ -527,10 +527,10 @@ fn test_automorphism_inplace(log_n: usize, basek: usize, p: i64, k_autokey: usiz let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct + basek - 1) / basek; - let mut autokey: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_autokey, rows, rank); - let mut ct: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut autokey: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_autokey, rows, rank); + let mut ct: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -548,13 +548,13 @@ fn test_automorphism_inplace(log_n: usize, basek: usize, p: i64, k_autokey: usiz | GLWECiphertext::automorphism_inplace_scratch_space(&module, ct.size(), rank, autokey.size()), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); - autokey.encrypt_sk( + autokey.generate_from_sk( &module, p, &sk, @@ -607,12 +607,12 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi let rows: usize = (k_ct_in + basek - 1) / basek; - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_rlwe_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank); - let mut ct_rlwe_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_rlwe_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_in, rank); + let mut ct_rlwe_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_out, rank); let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_in); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_out); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_in); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_out); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -642,10 +642,10 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi ), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_rgsw.encrypt_sk( @@ -711,11 +711,11 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct + basek - 1) / basek; - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -739,10 +739,10 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct | GLWECiphertext::external_product_inplace_scratch_space(&module, ct_rlwe.size(), ct_rgsw.size(), rank), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_rgsw.encrypt_sk( diff --git a/core/src/test_fft64/glwe_fourier.rs b/core/src/test_fft64/glwe_fourier.rs index d8bd11c..4a8c7c1 100644 --- a/core/src/test_fft64/glwe_fourier.rs +++ b/core/src/test_fft64/glwe_fourier.rs @@ -8,7 +8,7 @@ use crate::{ keyswitch_key::GLWESwitchingKey, test_fft64::{gglwe::log2_std_noise_gglwe_product, ggsw::noise_ggsw_product}, }; -use base2k::{FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, VecZnxToMut, ZnxViewMut}; +use backend::{FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, VecZnxToMut, ZnxViewMut}; use sampling::source::Source; #[test] @@ -59,14 +59,14 @@ fn test_keyswitch( let rows: usize = (k_ct_in + basek - 1) / basek; - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_in, rank_out); - let mut ct_glwe_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank_in); - let mut ct_glwe_dft_in: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct_in, rank_in); - let mut ct_glwe_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank_out); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_in, rank_out); + let mut ct_glwe_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_in, rank_in); + let mut ct_glwe_dft_in: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct_in, rank_in); + let mut ct_glwe_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_out, rank_out); let mut ct_glwe_dft_out: GLWECiphertextFourier, FFT64> = - GLWECiphertextFourier::new(&module, basek, k_ct_out, rank_out); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_in); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_out); + GLWECiphertextFourier::alloc(&module, basek, k_ct_out, rank_out); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_in); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_out); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -91,16 +91,16 @@ fn test_keyswitch( ), ); - let mut sk_in: SecretKey> = SecretKey::new(&module, rank_in); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank_in); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank_out); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank_out); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -157,11 +157,11 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct + basek - 1) / basek; - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank, rank); - let mut ct_glwe: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); - let mut ct_rlwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct, rank); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank, rank); + let mut ct_glwe: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); + let mut ct_rlwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct, rank); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -179,16 +179,16 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, | GLWECiphertextFourier::keyswitch_inplace_scratch_space(&module, ct_rlwe_dft.size(), ksk.size(), rank), ); - let mut sk_in: SecretKey> = SecretKey::new(&module, rank); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -246,14 +246,14 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi let rows: usize = (k_ct_in + basek - 1) / basek; - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank); - let mut ct_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank); - let mut ct_in_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct_in, rank); - let mut ct_out_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct_out, rank); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_in, rank); + let mut ct_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_out, rank); + let mut ct_in_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct_in, rank); + let mut ct_out_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct_out, rank); let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_in); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_out); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_in); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_out); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -277,10 +277,10 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi | GLWECiphertextFourier::external_product_scratch_space(&module, ct_out.size(), ct_in.size(), ct_rgsw.size(), rank), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_rgsw.encrypt_sk( @@ -348,12 +348,12 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct + basek - 1) / basek; - let mut ct_ggsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); - let mut ct_rlwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct, rank); + let mut ct_ggsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); + let mut ct_rlwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct, rank); let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -377,10 +377,10 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct | GLWECiphertextFourier::external_product_inplace_scratch_space(&module, ct.size(), ct_ggsw.size(), rank), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_ggsw.encrypt_sk( diff --git a/core/src/test_fft64/mod.rs b/core/src/test_fft64/mod.rs index fb2129e..912cdfd 100644 --- a/core/src/test_fft64/mod.rs +++ b/core/src/test_fft64/mod.rs @@ -4,3 +4,5 @@ mod ggsw; mod glwe; mod glwe_fourier; mod tensor_key; + +mod trace; diff --git a/core/src/test_fft64/tensor_key.rs b/core/src/test_fft64/tensor_key.rs index 920341b..ea90413 100644 --- a/core/src/test_fft64/tensor_key.rs +++ b/core/src/test_fft64/tensor_key.rs @@ -1,4 +1,4 @@ -use base2k::{FFT64, Module, ScalarZnx, ScalarZnxDftAlloc, ScalarZnxDftOps, ScratchOwned, Stats, VecZnxDftOps, VecZnxOps}; +use backend::{Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScratchOwned, Stats, VecZnxDftOps, VecZnxOps, FFT64}; use sampling::source::Source; use crate::{ @@ -22,7 +22,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize let rows: usize = (k + basek - 1) / basek; - let mut tensor_key: TensorKey, FFT64> = TensorKey::new(&module, basek, k, rows, rank); + let mut tensor_key: TensorKey, FFT64> = TensorKey::alloc(&module, basek, k, rows, rank); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -34,10 +34,10 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize tensor_key.size(), )); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); tensor_key.encrypt_sk( @@ -49,12 +49,12 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize scratch.borrow(), ); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); (0..rank).for_each(|i| { (0..rank).for_each(|j| { - let mut sk_ij_dft: base2k::ScalarZnxDft, FFT64> = module.new_scalar_znx_dft(1); + let mut sk_ij_dft: ScalarZnxDft, FFT64> = module.new_scalar_znx_dft(1); module.svp_apply(&mut sk_ij_dft, 0, &sk_dft.data, i, &sk_dft.data, j); let sk_ij: ScalarZnx> = module .vec_znx_idft_consume(sk_ij_dft.as_vec_znx_dft()) diff --git a/core/src/test_fft64/trace.rs b/core/src/test_fft64/trace.rs new file mode 100644 index 0000000..34f466a --- /dev/null +++ b/core/src/test_fft64/trace.rs @@ -0,0 +1,116 @@ +use std::collections::HashMap; + +use backend::{FFT64, FillUniform, Module, ScratchOwned, Stats, VecZnxOps, ZnxView, ZnxViewMut}; +use sampling::source::Source; + +use crate::{ + automorphism::AutomorphismKey, + elem::Infos, + glwe_ciphertext::GLWECiphertext, + glwe_plaintext::GLWEPlaintext, + keys::{SecretKey, SecretKeyFourier}, + test_fft64::gglwe::var_noise_gglwe_product, +}; + +#[test] +fn trace_inplace() { + (1..4).for_each(|rank| { + println!("test trace_inplace rank: {}", rank); + test_trace_inplace(11, 8, 54, 3.2, rank); + }); +} + +fn test_trace_inplace(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize) { + let module: Module = Module::::new(1 << log_n); + + let k_autokey: usize = k + basek; + + let rows: usize = (k + basek - 1) / basek; + + let mut ct: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k, rank); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); + + let mut source_xs: Source = Source::new([0u8; 32]); + let mut source_xe: Source = Source::new([0u8; 32]); + let mut source_xa: Source = Source::new([0u8; 32]); + + let mut scratch: ScratchOwned = ScratchOwned::new( + GLWECiphertext::encrypt_sk_scratch_space(&module, ct.size()) + | GLWECiphertext::decrypt_scratch_space(&module, ct.size()) + | AutomorphismKey::generate_from_sk_scratch_space(&module, rank, k_autokey) + | GLWECiphertext::trace_inplace_scratch_space(&module, ct.size(), k_autokey, rank), + ); + + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); + sk.fill_ternary_prob(0.5, &mut source_xs); + + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); + sk_dft.dft(&module, &sk); + + let mut data_want: Vec = vec![0i64; module.n()]; + + data_want + .iter_mut() + .for_each(|x| *x = source_xa.next_i64() & 0xFF); + + pt_have + .data + .fill_uniform(basek, 0, pt_have.size(), &mut source_xa); + + ct.encrypt_sk( + &module, + &pt_have, + &sk_dft, + &mut source_xa, + &mut source_xe, + sigma, + scratch.borrow(), + ); + + let mut auto_keys: HashMap, FFT64>> = HashMap::new(); + let gal_els: Vec = GLWECiphertext::trace_galois_elements(&module); + gal_els.iter().for_each(|gal_el| { + let mut key: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_autokey, rows, rank); + key.generate_from_sk( + &module, + *gal_el, + &sk, + &mut source_xa, + &mut source_xe, + sigma, + scratch.borrow(), + ); + auto_keys.insert(*gal_el, key); + }); + + ct.trace_inplace(&module, 0, 5, &auto_keys, scratch.borrow()); + ct.trace_inplace(&module, 5, log_n, &auto_keys, scratch.borrow()); + + (0..pt_want.size()).for_each(|i| pt_want.data.at_mut(0, i)[0] = pt_have.data.at(0, i)[0]); + + ct.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); + + module.vec_znx_sub_ab_inplace(&mut pt_want, 0, &pt_have, 0); + module.vec_znx_normalize_inplace(basek, &mut pt_want, 0, scratch.borrow()); + + let noise_have = pt_want.data.std(0, basek).log2(); + + let mut noise_want: f64 = var_noise_gglwe_product( + module.n() as f64, + basek, + 0.5, + 0.5, + 1.0 / 12.0, + sigma * sigma, + 0.0, + rank as f64, + k, + k_autokey, + ); + noise_want += sigma * sigma * (-2.0 * (k) as f64).exp2(); + noise_want += module.n() as f64 * 1.0 / 12.0 * 0.5 * rank as f64 * (-2.0 * (k) as f64).exp2(); + noise_want = noise_want.sqrt().log2(); + + assert!((noise_have - noise_want).abs() < 1.0); +} diff --git a/core/src/trace.rs b/core/src/trace.rs new file mode 100644 index 0000000..1169795 --- /dev/null +++ b/core/src/trace.rs @@ -0,0 +1,82 @@ +use std::collections::HashMap; + +use backend::{FFT64, MatZnxDft, MatZnxDftToRef, Module, Scratch, VecZnx, VecZnxToMut, VecZnxToRef}; + +use crate::{automorphism::AutomorphismKey, glwe_ciphertext::GLWECiphertext}; + +impl GLWECiphertext> { + pub fn trace_galois_elements(module: &Module) -> Vec { + let mut gal_els: Vec = Vec::new(); + (0..module.log_n()).for_each(|i| { + if i == 0 { + gal_els.push(-1); + } else { + gal_els.push(module.galois_element(1 << (i - 1))); + } + }); + gal_els + } + + pub fn trace_scratch_space( + module: &Module, + out_size: usize, + in_size: usize, + autokey_size: usize, + rank: usize, + ) -> usize { + Self::automorphism_inplace_scratch_space(module, out_size.max(in_size), rank, autokey_size) + } + + pub fn trace_inplace_scratch_space(module: &Module, out_size: usize, autokey_size: usize, rank: usize) -> usize { + Self::automorphism_inplace_scratch_space(module, out_size, rank, autokey_size) + } +} + +impl GLWECiphertext +where + VecZnx: VecZnxToMut + VecZnxToRef, +{ + pub fn trace( + &mut self, + module: &Module, + start: usize, + end: usize, + lhs: &GLWECiphertext, + auto_keys: &HashMap>, + scratch: &mut Scratch, + ) where + VecZnx: VecZnxToRef, + MatZnxDft: MatZnxDftToRef, + { + self.copy(lhs); + self.trace_inplace(module, start, end, auto_keys, scratch); + } + + pub fn trace_inplace( + &mut self, + module: &Module, + start: usize, + end: usize, + auto_keys: &HashMap>, + scratch: &mut Scratch, + ) where + MatZnxDft: MatZnxDftToRef, + { + (start..end).for_each(|i| { + self.rsh(1, scratch); + + let p: i64; + if i == 0 { + p = -1; + } else { + p = module.galois_element(1 << (i - 1)); + } + + if let Some(key) = auto_keys.get(&p) { + self.automorphism_add_inplace(module, key, scratch); + } else { + panic!("auto_keys[{}] is empty", p) + } + }); + } +}