arnaucube/poulpy
1
0
Fork 0
mirror of https://github.com/arnaucube/poulpy.git synced 2026-02-10 05:06:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

removed div_ceil

Browse Source
This commit is contained in:
Jean-Philippe Bossuat
2025-06-17 09:33:04 +02:00
parent e6ec588d6d
commit 4753b73cc7
15 changed files with 103 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
core/src/elem.rs
View File

@@ -1,6 +1,6 @@
use backend::{Backend, Module, ZnxInfos}; use backend::{Backend, Module, ZnxInfos};
use crate::{GLWECiphertextFourier, div_ceil}; use crate::GLWECiphertextFourier;
pub trait Infos { pub trait Infos {
type Inner: ZnxInfos; type Inner: ZnxInfos;
@@ -34,7 +34,7 @@ pub trait Infos {
/// Returns the number of size per polynomial. /// Returns the number of size per polynomial.
fn size(&self) -> usize { fn size(&self) -> usize {
let size: usize = self.inner().size(); let size: usize = self.inner().size();
debug_assert_eq!(size, div_ceil(self.k(), self.basek())); debug_assert_eq!(size, self.k().div_ceil(self.basek()));
size size
} }

8
core/src/gglwe_ciphertext.rs
View File

@@ -4,7 +4,7 @@ use backend::{
}; };
use sampling::source::Source; use sampling::source::Source;
use crate::{GLWECiphertext, GLWECiphertextFourier, GLWESecret, GetRow, Infos, ScratchCore, SetRow, div_ceil}; use crate::{GLWECiphertext, GLWECiphertextFourier, GLWESecret, GetRow, Infos, ScratchCore, SetRow};
pub struct GGLWECiphertext<C, B: Backend> { pub struct GGLWECiphertext<C, B: Backend> {
pub(crate) data: MatZnxDft<C, B>, pub(crate) data: MatZnxDft<C, B>,
@@ -23,7 +23,7 @@ impl<B: Backend> GGLWECiphertext<Vec<u8>, B> {
rank_in: usize, rank_in: usize,
rank_out: usize, rank_out: usize,
) -> Self { ) -> Self {
let size: usize = div_ceil(k, basek); let size: usize = k.div_ceil(basek);
debug_assert!( debug_assert!(
size > digits, size > digits,
"invalid gglwe: ceil(k/basek): {} <= digits: {}", "invalid gglwe: ceil(k/basek): {} <= digits: {}",
@@ -56,7 +56,7 @@ impl<B: Backend> GGLWECiphertext<Vec<u8>, B> {
rank_in: usize, rank_in: usize,
rank_out: usize, rank_out: usize,
) -> usize { ) -> usize {
let size: usize = div_ceil(k, basek); let size: usize = k.div_ceil(basek);
debug_assert!( debug_assert!(
size > digits, size > digits,
"invalid gglwe: ceil(k/basek): {} <= digits: {}", "invalid gglwe: ceil(k/basek): {} <= digits: {}",
@@ -112,7 +112,7 @@ impl<T, B: Backend> GGLWECiphertext<T, B> {
impl GGLWECiphertext<Vec<u8>, FFT64> { impl GGLWECiphertext<Vec<u8>, FFT64> {
pub fn generate_from_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize { pub fn generate_from_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize {
let size = div_ceil(k, basek); let size = k.div_ceil(basek);
GLWECiphertext::encrypt_sk_scratch_space(module, basek, k) GLWECiphertext::encrypt_sk_scratch_space(module, basek, k)
+ module.bytes_of_vec_znx(rank + 1, size) + module.bytes_of_vec_znx(rank + 1, size)
+ module.bytes_of_vec_znx(1, size) + module.bytes_of_vec_znx(1, size)

23
core/src/ggsw_ciphertext.rs
View File

@@ -7,7 +7,7 @@ use sampling::source::Source;
use crate::{ use crate::{
AutomorphismKey, GLWECiphertext, GLWECiphertextFourier, GLWESecret, GLWESwitchingKey, GetRow, Infos, ScratchCore, SetRow, AutomorphismKey, GLWECiphertext, GLWECiphertextFourier, GLWESecret, GLWESwitchingKey, GetRow, Infos, ScratchCore, SetRow,
TensorKey, div_ceil, TensorKey,
}; };
pub struct GGSWCiphertext<C, B: Backend> { pub struct GGSWCiphertext<C, B: Backend> {
@@ -19,7 +19,7 @@ pub struct GGSWCiphertext<C, B: Backend> {
impl<B: Backend> GGSWCiphertext<Vec<u8>, B> { impl<B: Backend> GGSWCiphertext<Vec<u8>, B> {
pub fn alloc(module: &Module<B>, basek: usize, k: usize, rows: usize, digits: usize, rank: usize) -> Self { pub fn alloc(module: &Module<B>, basek: usize, k: usize, rows: usize, digits: usize, rank: usize) -> Self {
let size: usize = div_ceil(k, basek); let size: usize = k.div_ceil(basek);
debug_assert!( debug_assert!(
size > digits, size > digits,
"invalid ggsw: ceil(k/basek): {} <= digits: {}", "invalid ggsw: ceil(k/basek): {} <= digits: {}",
@@ -36,7 +36,7 @@ impl<B: Backend> GGSWCiphertext<Vec<u8>, B> {
); );
Self { Self {
data: module.new_mat_znx_dft(rows, rank + 1, rank + 1, div_ceil(k, basek)), data: module.new_mat_znx_dft(rows, rank + 1, rank + 1, k.div_ceil(basek)),
basek, basek,
k: k, k: k,
digits, digits,
@@ -44,7 +44,7 @@ impl<B: Backend> GGSWCiphertext<Vec<u8>, B> {
} }
pub fn bytes_of(module: &Module<FFT64>, basek: usize, k: usize, rows: usize, digits: usize, rank: usize) -> usize { pub fn bytes_of(module: &Module<FFT64>, basek: usize, k: usize, rows: usize, digits: usize, rank: usize) -> usize {
let size: usize = div_ceil(k, basek); let size: usize = k.div_ceil(basek);
debug_assert!( debug_assert!(
size > digits, size > digits,
"invalid ggsw: ceil(k/basek): {} <= digits: {}", "invalid ggsw: ceil(k/basek): {} <= digits: {}",
@@ -92,7 +92,7 @@ impl<T, B: Backend> GGSWCiphertext<T, B> {
impl GGSWCiphertext<Vec<u8>, FFT64> { impl GGSWCiphertext<Vec<u8>, FFT64> {
pub fn encrypt_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize { pub fn encrypt_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize {
let size = div_ceil(k, basek); let size = k.div_ceil(basek);
GLWECiphertext::encrypt_sk_scratch_space(module, basek, k) GLWECiphertext::encrypt_sk_scratch_space(module, basek, k)
+ module.bytes_of_vec_znx(rank + 1, size) + module.bytes_of_vec_znx(rank + 1, size)
+ module.bytes_of_vec_znx(1, size) + module.bytes_of_vec_znx(1, size)
@@ -107,9 +107,9 @@ impl GGSWCiphertext<Vec<u8>, FFT64> {
digits: usize, digits: usize,
rank: usize, rank: usize,
) -> usize { ) -> usize {
let tsk_size: usize = div_ceil(k_tsk, basek); let tsk_size: usize = k_tsk.div_ceil(basek);
let self_size_out: usize = div_ceil(self_k, basek); let self_size_out: usize = self_k.div_ceil(basek);
let self_size_in: usize = div_ceil(self_size_out, digits); let self_size_in: usize = self_size_out.div_ceil(digits);
let tmp_dft_i: usize = module.bytes_of_vec_znx_dft(rank + 1, tsk_size); let tmp_dft_i: usize = module.bytes_of_vec_znx_dft(rank + 1, tsk_size);
let tmp_a: usize = module.bytes_of_vec_znx_dft(1, self_size_in); let tmp_a: usize = module.bytes_of_vec_znx_dft(1, self_size_in);
let vmp: usize = module.vmp_apply_tmp_bytes( let vmp: usize = module.vmp_apply_tmp_bytes(
@@ -135,7 +135,7 @@ impl GGSWCiphertext<Vec<u8>, FFT64> {
rank: usize, rank: usize,
) -> usize { ) -> usize {
GLWECiphertext::keyswitch_from_fourier_scratch_space(module, basek, k_out, k_in, k_ksk, digits, rank, rank) GLWECiphertext::keyswitch_from_fourier_scratch_space(module, basek, k_out, k_in, k_ksk, digits, rank, rank)
+ module.bytes_of_vec_znx_dft(rank + 1, div_ceil(k_in, basek)) + module.bytes_of_vec_znx_dft(rank + 1, k_in.div_ceil(basek))
} }
pub fn keyswitch_scratch_space( pub fn keyswitch_scratch_space(
@@ -149,8 +149,7 @@ impl GGSWCiphertext<Vec<u8>, FFT64> {
digits_tsk: usize, digits_tsk: usize,
rank: usize, rank: usize,
) -> usize { ) -> usize {
let out_size: usize = div_ceil(k_out, basek); let out_size: usize = k_out.div_ceil(basek);
let res_znx: usize = module.bytes_of_vec_znx(rank + 1, out_size); let res_znx: usize = module.bytes_of_vec_znx(rank + 1, out_size);
let ci_dft: usize = module.bytes_of_vec_znx_dft(rank + 1, out_size); let ci_dft: usize = module.bytes_of_vec_znx_dft(rank + 1, out_size);
let ks: usize = let ks: usize =
@@ -187,7 +186,7 @@ impl GGSWCiphertext<Vec<u8>, FFT64> {
rank: usize, rank: usize,
) -> usize { ) -> usize {
let cols: usize = rank + 1; let cols: usize = rank + 1;
let out_size: usize = div_ceil(k_out, basek); let out_size: usize = k_out.div_ceil(basek);
let res: usize = module.bytes_of_vec_znx(cols, out_size); let res: usize = module.bytes_of_vec_znx(cols, out_size);
let res_dft: usize = module.bytes_of_vec_znx_dft(cols, out_size); let res_dft: usize = module.bytes_of_vec_znx_dft(cols, out_size);
let ci_dft: usize = module.bytes_of_vec_znx_dft(cols, out_size); let ci_dft: usize = module.bytes_of_vec_znx_dft(cols, out_size);

24
core/src/glwe_ciphertext.rs
View File

@@ -7,7 +7,7 @@ use sampling::source::Source;
use crate::{ use crate::{
AutomorphismKey, GGSWCiphertext, GLWECiphertextFourier, GLWEOps, GLWEPlaintext, GLWEPublicKey, GLWESecret, GLWESwitchingKey, AutomorphismKey, GGSWCiphertext, GLWECiphertextFourier, GLWEOps, GLWEPlaintext, GLWEPublicKey, GLWESecret, GLWESwitchingKey,
Infos, SIX_SIGMA, SecretDistribution, SetMetaData, div_ceil, Infos, SIX_SIGMA, SecretDistribution, SetMetaData,
}; };
pub struct GLWECiphertext<C> { pub struct GLWECiphertext<C> {
@@ -19,14 +19,14 @@ pub struct GLWECiphertext<C> {
impl GLWECiphertext<Vec<u8>> { impl GLWECiphertext<Vec<u8>> {
pub fn alloc<B: Backend>(module: &Module<B>, basek: usize, k: usize, rank: usize) -> Self { pub fn alloc<B: Backend>(module: &Module<B>, basek: usize, k: usize, rank: usize) -> Self {
Self { Self {
data: module.new_vec_znx(rank + 1, div_ceil(k, basek)), data: module.new_vec_znx(rank + 1, k.div_ceil(basek)),
basek, basek,
k, k,
} }
} }
pub fn bytes_of(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize { pub fn bytes_of(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize {
module.bytes_of_vec_znx(rank + 1, div_ceil(k, basek)) module.bytes_of_vec_znx(rank + 1, k.div_ceil(basek))
} }
} }
@@ -69,18 +69,18 @@ impl<C: AsRef<[u8]>> GLWECiphertext<C> {
impl GLWECiphertext<Vec<u8>> { impl GLWECiphertext<Vec<u8>> {
pub fn encrypt_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize) -> usize { pub fn encrypt_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize) -> usize {
let size: usize = div_ceil(k, basek); let size: usize = k.div_ceil(basek);
module.vec_znx_big_normalize_tmp_bytes() + module.bytes_of_vec_znx_dft(1, size) + module.bytes_of_vec_znx(1, size) module.vec_znx_big_normalize_tmp_bytes() + module.bytes_of_vec_znx_dft(1, size) + module.bytes_of_vec_znx(1, size)
} }
pub fn encrypt_pk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize) -> usize { pub fn encrypt_pk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize) -> usize {
let size: usize = div_ceil(k, basek); let size: usize = k.div_ceil(basek);
((module.bytes_of_vec_znx_dft(1, size) + module.bytes_of_vec_znx_big(1, size)) | module.bytes_of_scalar_znx(1)) ((module.bytes_of_vec_znx_dft(1, size) + module.bytes_of_vec_znx_big(1, size)) | module.bytes_of_scalar_znx(1))
+ module.bytes_of_scalar_znx_dft(1) + module.bytes_of_scalar_znx_dft(1)
+ module.vec_znx_big_normalize_tmp_bytes() + module.vec_znx_big_normalize_tmp_bytes()
} }
pub fn decrypt_scratch_space(module: &Module<FFT64>, basek: usize, k: usize) -> usize { pub fn decrypt_scratch_space(module: &Module<FFT64>, basek: usize, k: usize) -> usize {
let size: usize = div_ceil(k, basek); let size: usize = k.div_ceil(basek);
(module.vec_znx_big_normalize_tmp_bytes() | module.bytes_of_vec_znx_dft(1, size)) + module.bytes_of_vec_znx_big(1, size) (module.vec_znx_big_normalize_tmp_bytes() | module.bytes_of_vec_znx_dft(1, size)) + module.bytes_of_vec_znx_big(1, size)
} }
@@ -95,9 +95,9 @@ impl GLWECiphertext<Vec<u8>> {
rank_out: usize, rank_out: usize,
) -> usize { ) -> usize {
let res_dft: usize = GLWECiphertextFourier::bytes_of(module, basek, k_out, rank_out + 1); let res_dft: usize = GLWECiphertextFourier::bytes_of(module, basek, k_out, rank_out + 1);
let in_size: usize = div_ceil(div_ceil(k_in, basek), digits); let in_size: usize = k_in.div_ceil(basek).div_ceil(digits);
let out_size: usize = div_ceil(k_out, basek); let out_size: usize = k_out.div_ceil(basek);
let ksk_size: usize = div_ceil(k_ksk, basek); let ksk_size: usize = k_ksk.div_ceil(basek);
let ai_dft: usize = module.bytes_of_vec_znx_dft(rank_in, in_size); let ai_dft: usize = module.bytes_of_vec_znx_dft(rank_in, in_size);
let vmp: usize = module.vmp_apply_tmp_bytes(out_size, in_size, in_size, rank_in, rank_out + 1, ksk_size) let vmp: usize = module.vmp_apply_tmp_bytes(out_size, in_size, in_size, rank_in, rank_out + 1, ksk_size)
+ module.bytes_of_vec_znx_dft(rank_in, in_size); + module.bytes_of_vec_znx_dft(rank_in, in_size);
@@ -162,9 +162,9 @@ impl GLWECiphertext<Vec<u8>> {
rank: usize, rank: usize,
) -> usize { ) -> usize {
let res_dft: usize = GLWECiphertextFourier::bytes_of(module, basek, k_out, rank); let res_dft: usize = GLWECiphertextFourier::bytes_of(module, basek, k_out, rank);
let in_size: usize = div_ceil(div_ceil(k_in, basek), digits); let in_size: usize = k_in.div_ceil(basek).div_ceil(digits);
let out_size: usize = div_ceil(k_out, basek); let out_size: usize = k_out.div_ceil(basek);
let ggsw_size: usize = div_ceil(ggsw_k, basek); let ggsw_size: usize = ggsw_k.div_ceil(basek);
let vmp: usize = module.bytes_of_vec_znx_dft(rank + 1, in_size) let vmp: usize = module.bytes_of_vec_znx_dft(rank + 1, in_size)
+ module.vmp_apply_tmp_bytes( + module.vmp_apply_tmp_bytes(
out_size, out_size,

18
core/src/glwe_ciphertext_fourier.rs
View File

@@ -4,7 +4,7 @@ use backend::{
}; };
use sampling::source::Source; use sampling::source::Source;
use crate::{GGSWCiphertext, GLWECiphertext, GLWEPlaintext, GLWESecret, GLWESwitchingKey, Infos, ScratchCore, div_ceil}; use crate::{GGSWCiphertext, GLWECiphertext, GLWEPlaintext, GLWESecret, GLWESwitchingKey, Infos, ScratchCore};
pub struct GLWECiphertextFourier<C, B: Backend> { pub struct GLWECiphertextFourier<C, B: Backend> {
pub data: VecZnxDft<C, B>, pub data: VecZnxDft<C, B>,
@@ -15,14 +15,14 @@ pub struct GLWECiphertextFourier<C, B: Backend> {
impl<B: Backend> GLWECiphertextFourier<Vec<u8>, B> { impl<B: Backend> GLWECiphertextFourier<Vec<u8>, B> {
pub fn alloc(module: &Module<B>, basek: usize, k: usize, rank: usize) -> Self { pub fn alloc(module: &Module<B>, basek: usize, k: usize, rank: usize) -> Self {
Self { Self {
data: module.new_vec_znx_dft(rank + 1, div_ceil(k, basek)), data: module.new_vec_znx_dft(rank + 1, k.div_ceil(basek)),
basek: basek, basek: basek,
k: k, k: k,
} }
} }
pub fn bytes_of(module: &Module<B>, basek: usize, k: usize, rank: usize) -> usize { pub fn bytes_of(module: &Module<B>, basek: usize, k: usize, rank: usize) -> usize {
module.bytes_of_vec_znx_dft(rank + 1, div_ceil(k, basek)) module.bytes_of_vec_znx_dft(rank + 1, k.div_ceil(basek))
} }
} }
@@ -51,16 +51,16 @@ impl<T, B: Backend> GLWECiphertextFourier<T, B> {
impl GLWECiphertextFourier<Vec<u8>, FFT64> { impl GLWECiphertextFourier<Vec<u8>, FFT64> {
#[allow(dead_code)] #[allow(dead_code)]
pub(crate) fn idft_scratch_space(module: &Module<FFT64>, basek: usize, k: usize) -> usize { pub(crate) fn idft_scratch_space(module: &Module<FFT64>, basek: usize, k: usize) -> usize {
module.bytes_of_vec_znx(1, div_ceil(k, basek)) module.bytes_of_vec_znx(1, k.div_ceil(basek))
+ (module.vec_znx_big_normalize_tmp_bytes() | module.vec_znx_idft_tmp_bytes()) + (module.vec_znx_big_normalize_tmp_bytes() | module.vec_znx_idft_tmp_bytes())
} }
pub fn encrypt_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize { pub fn encrypt_sk_scratch_space(module: &Module<FFT64>, basek: usize, k: usize, rank: usize) -> usize {
module.bytes_of_vec_znx(rank + 1, div_ceil(k, basek)) + GLWECiphertext::encrypt_sk_scratch_space(module, basek, k) module.bytes_of_vec_znx(rank + 1, k.div_ceil(basek)) + GLWECiphertext::encrypt_sk_scratch_space(module, basek, k)
} }
pub fn decrypt_scratch_space(module: &Module<FFT64>, basek: usize, k: usize) -> usize { pub fn decrypt_scratch_space(module: &Module<FFT64>, basek: usize, k: usize) -> usize {
let size: usize = div_ceil(k, basek); let size: usize = k.div_ceil(basek);
(module.vec_znx_big_normalize_tmp_bytes() (module.vec_znx_big_normalize_tmp_bytes()
| module.bytes_of_vec_znx_dft(1, size) | module.bytes_of_vec_znx_dft(1, size)
| (module.bytes_of_vec_znx_big(1, size) + module.vec_znx_idft_tmp_bytes())) | (module.bytes_of_vec_znx_big(1, size) + module.vec_znx_idft_tmp_bytes()))
@@ -102,10 +102,10 @@ impl GLWECiphertextFourier<Vec<u8>, FFT64> {
digits: usize, digits: usize,
rank: usize, rank: usize,
) -> usize { ) -> usize {
let ggsw_size: usize = div_ceil(k_ggsw, basek); let ggsw_size: usize = k_ggsw.div_ceil(basek);
let res_dft: usize = module.bytes_of_vec_znx_dft(rank + 1, ggsw_size); let res_dft: usize = module.bytes_of_vec_znx_dft(rank + 1, ggsw_size);
let in_size: usize = div_ceil(div_ceil(k_in, basek), digits); let in_size: usize = k_in.div_ceil(basek).div_ceil(digits);
let ggsw_size: usize = div_ceil(k_ggsw, basek); let ggsw_size: usize = k_ggsw.div_ceil(basek);
let vmp: usize = module.bytes_of_vec_znx_dft(rank + 1, in_size) let vmp: usize = module.bytes_of_vec_znx_dft(rank + 1, in_size)
+ module.vmp_apply_tmp_bytes(ggsw_size, in_size, in_size, rank + 1, rank + 1, ggsw_size); + module.vmp_apply_tmp_bytes(ggsw_size, in_size, in_size, rank + 1, rank + 1, ggsw_size);
let res_small: usize = module.bytes_of_vec_znx(rank + 1, ggsw_size); let res_small: usize = module.bytes_of_vec_znx(rank + 1, ggsw_size);

6
core/src/glwe_plaintext.rs
View File

@@ -1,6 +1,6 @@
use backend::{Backend, FFT64, Module, VecZnx, VecZnxAlloc, VecZnxToMut, VecZnxToRef}; use backend::{Backend, FFT64, Module, VecZnx, VecZnxAlloc, VecZnxToMut, VecZnxToRef};
use crate::{GLWECiphertext, GLWECiphertextToMut, GLWECiphertextToRef, GLWEOps, Infos, SetMetaData, div_ceil}; use crate::{GLWECiphertext, GLWECiphertextToMut, GLWECiphertextToRef, GLWEOps, Infos, SetMetaData};
pub struct GLWEPlaintext<C> { pub struct GLWEPlaintext<C> {
pub data: VecZnx<C>, pub data: VecZnx<C>,
@@ -37,14 +37,14 @@ impl<DataSelf: AsMut<[u8]> + AsRef<[u8]>> SetMetaData for GLWEPlaintext<DataSelf
impl GLWEPlaintext<Vec<u8>> { impl GLWEPlaintext<Vec<u8>> {
pub fn alloc<B: Backend>(module: &Module<B>, basek: usize, k: usize) -> Self { pub fn alloc<B: Backend>(module: &Module<B>, basek: usize, k: usize) -> Self {
Self { Self {
data: module.new_vec_znx(1, div_ceil(k, basek)), data: module.new_vec_znx(1, k.div_ceil(basek)),
basek: basek, basek: basek,
k, k,
} }
} }
pub fn byte_of(module: &Module<FFT64>, basek: usize, k: usize) -> usize { pub fn byte_of(module: &Module<FFT64>, basek: usize, k: usize) -> usize {
module.bytes_of_vec_znx(1, div_ceil(k, basek)) module.bytes_of_vec_znx(1, k.div_ceil(basek))
} }
} }

16
core/src/lib.rs
View File

@@ -13,7 +13,6 @@ pub mod tensor_key;
#[cfg(test)] #[cfg(test)]
mod test_fft64; mod test_fft64;
pub mod trace; pub mod trace;
mod utils;
pub use automorphism::*; pub use automorphism::*;
use backend::Backend; use backend::Backend;
@@ -33,7 +32,6 @@ pub use tensor_key::*;
pub use backend::Scratch; pub use backend::Scratch;
pub use backend::ScratchOwned; pub use backend::ScratchOwned;
use utils::div_ceil;
pub(crate) const SIX_SIGMA: f64 = 6.0; pub(crate) const SIX_SIGMA: f64 = 6.0;
@@ -112,12 +110,12 @@ impl ScratchCore<FFT64> for Scratch {
k: usize, k: usize,
rank: usize, rank: usize,
) -> (GLWECiphertext<&mut [u8]>, &mut Self) { ) -> (GLWECiphertext<&mut [u8]>, &mut Self) {
let (data, scratch) = self.tmp_vec_znx(module, rank + 1, div_ceil(k, basek)); let (data, scratch) = self.tmp_vec_znx(module, rank + 1, k.div_ceil(basek));
(GLWECiphertext { data, basek, k }, scratch) (GLWECiphertext { data, basek, k }, scratch)
} }
fn tmp_glwe_pt(&mut self, module: &Module<FFT64>, basek: usize, k: usize) -> (GLWEPlaintext<&mut [u8]>, &mut Self) { fn tmp_glwe_pt(&mut self, module: &Module<FFT64>, basek: usize, k: usize) -> (GLWEPlaintext<&mut [u8]>, &mut Self) {
let (data, scratch) = self.tmp_vec_znx(module, 1, div_ceil(k, basek)); let (data, scratch) = self.tmp_vec_znx(module, 1, k.div_ceil(basek));
(GLWEPlaintext { data, basek, k }, scratch) (GLWEPlaintext { data, basek, k }, scratch)
} }
@@ -133,10 +131,10 @@ impl ScratchCore<FFT64> for Scratch {
) -> (GGLWECiphertext<&mut [u8], FFT64>, &mut Self) { ) -> (GGLWECiphertext<&mut [u8], FFT64>, &mut Self) {
let (data, scratch) = self.tmp_mat_znx_dft( let (data, scratch) = self.tmp_mat_znx_dft(
module, module,
div_ceil(rows, digits), rows.div_ceil(digits),
rank_in, rank_in,
rank_out + 1, rank_out + 1,
div_ceil(k, basek), k.div_ceil(basek),
); );
( (
GGLWECiphertext { GGLWECiphertext {
@@ -160,10 +158,10 @@ impl ScratchCore<FFT64> for Scratch {
) -> (GGSWCiphertext<&mut [u8], FFT64>, &mut Self) { ) -> (GGSWCiphertext<&mut [u8], FFT64>, &mut Self) {
let (data, scratch) = self.tmp_mat_znx_dft( let (data, scratch) = self.tmp_mat_znx_dft(
module, module,
div_ceil(rows, digits), rows.div_ceil(digits),
rank + 1, rank + 1,
rank + 1, rank + 1,
div_ceil(k, basek), k.div_ceil(basek),
); );
( (
GGSWCiphertext { GGSWCiphertext {
@@ -183,7 +181,7 @@ impl ScratchCore<FFT64> for Scratch {
k: usize, k: usize,
rank: usize, rank: usize,
) -> (GLWECiphertextFourier<&mut [u8], FFT64>, &mut Self) { ) -> (GLWECiphertextFourier<&mut [u8], FFT64>, &mut Self) {
let (data, scratch) = self.tmp_vec_znx_dft(module, rank + 1, div_ceil(k, basek)); let (data, scratch) = self.tmp_vec_znx_dft(module, rank + 1, k.div_ceil(basek));
(GLWECiphertextFourier { data, basek, k }, scratch) (GLWECiphertextFourier { data, basek, k }, scratch)
} }

11
core/src/test_fft64/automorphism_key.rs
View File

@@ -2,8 +2,7 @@ use backend::{FFT64, Module, ScalarZnxOps, ScratchOwned, Stats, VecZnxOps};
use sampling::source::Source; use sampling::source::Source;
use crate::{ use crate::{
AutomorphismKey, GLWECiphertextFourier, GLWEPlaintext, GLWESecret, GetRow, Infos, div_ceil, AutomorphismKey, GLWECiphertextFourier, GLWEPlaintext, GLWESecret, GetRow, Infos, test_fft64::log2_std_noise_gglwe_product,
test_fft64::log2_std_noise_gglwe_product,
}; };
#[test] #[test]
@@ -12,7 +11,7 @@ fn automorphism() {
let basek: usize = 12; let basek: usize = 12;
let k_in: usize = 60; let k_in: usize = 60;
let k_out: usize = 60; let k_out: usize = 60;
let digits: usize = div_ceil(k_in, basek); let digits: usize = k_in.div_ceil(basek);
let sigma: f64 = 3.2; let sigma: f64 = 3.2;
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(2..digits + 1).for_each(|di| { (2..digits + 1).for_each(|di| {
@@ -28,7 +27,7 @@ fn automorphism_inplace() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_in: usize = 60; let k_in: usize = 60;
let digits: usize = div_ceil(k_in, basek); let digits: usize = k_in.div_ceil(basek);
let sigma: f64 = 3.2; let sigma: f64 = 3.2;
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(2..digits + 1).for_each(|di| { (2..digits + 1).for_each(|di| {
@@ -56,7 +55,7 @@ fn test_automorphism(
let digits_in: usize = 1; let digits_in: usize = 1;
let rows_in: usize = k_in / (basek * digits); let rows_in: usize = k_in / (basek * digits);
let rows_apply: usize = div_ceil(k_in, basek * digits); let rows_apply: usize = k_in.div_ceil(basek * digits);
let mut auto_key_in: AutomorphismKey<Vec<u8>, FFT64> = AutomorphismKey::alloc(&module, basek, k_in, rows_in, digits_in, rank); let mut auto_key_in: AutomorphismKey<Vec<u8>, FFT64> = AutomorphismKey::alloc(&module, basek, k_in, rows_in, digits_in, rank);
let mut auto_key_out: AutomorphismKey<Vec<u8>, FFT64> = let mut auto_key_out: AutomorphismKey<Vec<u8>, FFT64> =
@@ -172,7 +171,7 @@ fn test_automorphism_inplace(
let digits_in: usize = 1; let digits_in: usize = 1;
let rows_in: usize = k_in / (basek * digits); let rows_in: usize = k_in / (basek * digits);
let rows_apply: usize = div_ceil(k_in, basek * digits); let rows_apply: usize = k_in.div_ceil(basek * digits);
let mut auto_key: AutomorphismKey<Vec<u8>, FFT64> = AutomorphismKey::alloc(&module, basek, k_in, rows_in, digits_in, rank); let mut auto_key: AutomorphismKey<Vec<u8>, FFT64> = AutomorphismKey::alloc(&module, basek, k_in, rows_in, digits_in, rank);
let mut auto_key_apply: AutomorphismKey<Vec<u8>, FFT64> = let mut auto_key_apply: AutomorphismKey<Vec<u8>, FFT64> =

18
core/src/test_fft64/gglwe.rs
View File

@@ -2,7 +2,7 @@ use backend::{FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxToMut, ScratchO
use sampling::source::Source; use sampling::source::Source;
use crate::{ use crate::{
GGSWCiphertext, GLWECiphertextFourier, GLWEPlaintext, GLWESecret, GLWESwitchingKey, GetRow, Infos, div_ceil, GGSWCiphertext, GLWECiphertextFourier, GLWEPlaintext, GLWESecret, GLWESwitchingKey, GetRow, Infos,
test_fft64::{log2_std_noise_gglwe_product, noise_ggsw_product}, test_fft64::{log2_std_noise_gglwe_product, noise_ggsw_product},
}; };
@@ -30,7 +30,7 @@ fn key_switch() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_in: usize = 60; let k_in: usize = 60;
let digits: usize = div_ceil(k_in, basek); let digits: usize = k_in.div_ceil(basek);
(1..4).for_each(|rank_in_s0s1| { (1..4).for_each(|rank_in_s0s1| {
(1..4).for_each(|rank_out_s0s1| { (1..4).for_each(|rank_out_s0s1| {
(1..4).for_each(|rank_out_s1s2| { (1..4).for_each(|rank_out_s1s2| {
@@ -64,7 +64,7 @@ fn key_switch_inplace() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_ct: usize = 60; let k_ct: usize = 60;
let digits: usize = div_ceil(k_ct, basek); let digits: usize = k_ct.div_ceil(basek);
(1..4).for_each(|rank_in_s0s1| { (1..4).for_each(|rank_in_s0s1| {
(1..4).for_each(|rank_out_s0s1| { (1..4).for_each(|rank_out_s0s1| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
@@ -93,7 +93,7 @@ fn external_product() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_in: usize = 60; let k_in: usize = 60;
let digits: usize = div_ceil(k_in, basek); let digits: usize = k_in.div_ceil(basek);
(1..4).for_each(|rank_in| { (1..4).for_each(|rank_in| {
(1..4).for_each(|rank_out| { (1..4).for_each(|rank_out| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
@@ -116,7 +116,7 @@ fn external_product_inplace() {
let log_n: usize = 5; let log_n: usize = 5;
let basek: usize = 12; let basek: usize = 12;
let k_ct: usize = 60; let k_ct: usize = 60;
let digits: usize = div_ceil(k_ct, basek); let digits: usize = k_ct.div_ceil(basek);
(1..4).for_each(|rank_in| { (1..4).for_each(|rank_in| {
(1..4).for_each(|rank_out| { (1..4).for_each(|rank_out| {
(1..digits).for_each(|di| { (1..digits).for_each(|di| {
@@ -197,7 +197,7 @@ fn test_key_switch(
sigma: f64, sigma: f64,
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_in, basek * digits); let rows: usize = k_in.div_ceil(basek * digits);
let digits_in: usize = 1; let digits_in: usize = 1;
let mut ct_gglwe_s0s1: GLWESwitchingKey<Vec<u8>, FFT64> = GLWESwitchingKey::alloc( let mut ct_gglwe_s0s1: GLWESwitchingKey<Vec<u8>, FFT64> = GLWESwitchingKey::alloc(
@@ -332,7 +332,7 @@ fn test_key_switch_inplace(
sigma: f64, sigma: f64,
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_ct, basek * digits); let rows: usize = k_ct.div_ceil(basek * digits);
let digits_in: usize = 1; let digits_in: usize = 1;
let mut ct_gglwe_s0s1: GLWESwitchingKey<Vec<u8>, FFT64> = let mut ct_gglwe_s0s1: GLWESwitchingKey<Vec<u8>, FFT64> =
@@ -438,7 +438,7 @@ fn test_external_product(
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_in, basek * digits); let rows: usize = k_in.div_ceil(basek * digits);
let digits_in: usize = 1; let digits_in: usize = 1;
let mut ct_gglwe_in: GLWESwitchingKey<Vec<u8>, FFT64> = let mut ct_gglwe_in: GLWESwitchingKey<Vec<u8>, FFT64> =
@@ -559,7 +559,7 @@ fn test_external_product_inplace(
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_ct, basek * digits); let rows: usize = k_ct.div_ceil(basek * digits);
let digits_in: usize = 1; let digits_in: usize = 1;

33
core/src/test_fft64/ggsw.rs
View File

@@ -7,7 +7,6 @@ use sampling::source::Source;
use crate::{ use crate::{
GGSWCiphertext, GLWECiphertextFourier, GLWEPlaintext, GLWESecret, GLWESwitchingKey, GetRow, Infos, TensorKey, GGSWCiphertext, GLWECiphertextFourier, GLWEPlaintext, GLWESecret, GLWESwitchingKey, GetRow, Infos, TensorKey,
automorphism::AutomorphismKey, automorphism::AutomorphismKey,
div_ceil,
test_fft64::{noise_ggsw_keyswitch, noise_ggsw_product}, test_fft64::{noise_ggsw_keyswitch, noise_ggsw_product},
}; };
@@ -30,7 +29,7 @@ fn keyswitch() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_in: usize = 54; let k_in: usize = 54;
let digits: usize = div_ceil(k_in, basek); let digits: usize = k_in.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
let k_ksk: usize = k_in + basek * di; let k_ksk: usize = k_in + basek * di;
@@ -47,7 +46,7 @@ fn keyswitch_inplace() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_ct: usize = 54; let k_ct: usize = 54;
let digits: usize = div_ceil(k_ct, basek); let digits: usize = k_ct.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
let k_ksk: usize = k_ct + basek * di; let k_ksk: usize = k_ct + basek * di;
@@ -63,7 +62,7 @@ fn automorphism() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_in: usize = 54; let k_in: usize = 54;
let digits: usize = div_ceil(k_in, basek); let digits: usize = k_in.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
let k_ksk: usize = k_in + basek * di; let k_ksk: usize = k_in + basek * di;
@@ -80,7 +79,7 @@ fn automorphism_inplace() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_ct: usize = 54; let k_ct: usize = 54;
let digits: usize = div_ceil(k_ct, basek); let digits: usize = k_ct.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
let k_ksk: usize = k_ct + basek * di; let k_ksk: usize = k_ct + basek * di;
@@ -96,7 +95,7 @@ fn external_product() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_in: usize = 60; let k_in: usize = 60;
let digits: usize = div_ceil(k_in, basek); let digits: usize = k_in.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
let k_ggsw: usize = k_in + basek * di; let k_ggsw: usize = k_in + basek * di;
@@ -112,7 +111,7 @@ fn external_product_inplace() {
let log_n: usize = 5; let log_n: usize = 5;
let basek: usize = 12; let basek: usize = 12;
let k_ct: usize = 60; let k_ct: usize = 60;
let digits: usize = div_ceil(k_ct, basek); let digits: usize = k_ct.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits).for_each(|di| { (1..digits).for_each(|di| {
let k_ggsw: usize = k_ct + basek * di; let k_ggsw: usize = k_ct + basek * di;
@@ -204,7 +203,7 @@ fn test_keyswitch(
sigma: f64, sigma: f64,
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_in, digits * basek); let rows: usize = k_in.div_ceil(digits * basek);
let digits_in: usize = 1; let digits_in: usize = 1;
@@ -332,7 +331,7 @@ fn test_keyswitch_inplace(
sigma: f64, sigma: f64,
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_ct, digits * basek); let rows: usize = k_ct.div_ceil(digits * basek);
let digits_in: usize = 1; let digits_in: usize = 1;
@@ -465,8 +464,8 @@ fn test_automorphism(
sigma: f64, sigma: f64,
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_in, basek * digits); let rows: usize = k_in.div_ceil(basek * digits);
let rows_in: usize = k_in / (basek * digits); let rows_in: usize = k_in.div_euclid(basek * digits);
let digits_in: usize = 1; let digits_in: usize = 1;
@@ -592,8 +591,8 @@ fn test_automorphism_inplace(
sigma: f64, sigma: f64,
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_ct, digits * basek); let rows: usize = k_ct.div_ceil(digits * basek);
let rows_in: usize = k_ct / (basek * digits); let rows_in: usize = k_ct.div_euclid(basek * digits);
let digits_in: usize = 1; let digits_in: usize = 1;
let mut ct: GGSWCiphertext<Vec<u8>, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ct, rows_in, digits_in, rank); let mut ct: GGSWCiphertext<Vec<u8>, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ct, rows_in, digits_in, rank);
@@ -715,8 +714,8 @@ fn test_external_product(
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_in, basek * digits); let rows: usize = k_in.div_ceil(basek * digits);
let rows_in: usize = k_in / (basek * digits); let rows_in: usize = k_in.div_euclid(basek * digits);
let digits_in: usize = 1; let digits_in: usize = 1;
let mut ct_ggsw_lhs_in: GGSWCiphertext<Vec<u8>, FFT64> = let mut ct_ggsw_lhs_in: GGSWCiphertext<Vec<u8>, FFT64> =
@@ -837,8 +836,8 @@ fn test_external_product(
fn test_external_product_inplace(log_n: usize, basek: usize, k_ct: usize, k_ggsw: usize, digits: usize, rank: usize, sigma: f64) { fn test_external_product_inplace(log_n: usize, basek: usize, k_ct: usize, k_ggsw: usize, digits: usize, rank: usize, sigma: f64) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_ct, digits * basek); let rows: usize = k_ct.div_ceil(digits * basek);
let rows_in: usize = k_ct / (basek * digits); let rows_in: usize = k_ct.div_euclid(basek * digits);
let digits_in: usize = 1; let digits_in: usize = 1;
let mut ct_ggsw_lhs: GGSWCiphertext<Vec<u8>, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ct, rows_in, digits_in, rank); let mut ct_ggsw_lhs: GGSWCiphertext<Vec<u8>, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ct, rows_in, digits_in, rank);

25
core/src/test_fft64/glwe.rs
View File

@@ -8,7 +8,6 @@ use sampling::source::Source;
use crate::{ use crate::{
GGSWCiphertext, GLWECiphertext, GLWECiphertextFourier, GLWEPlaintext, GLWEPublicKey, GLWESecret, Infos, GGSWCiphertext, GLWECiphertext, GLWECiphertextFourier, GLWEPlaintext, GLWEPublicKey, GLWESecret, Infos,
automorphism::AutomorphismKey, automorphism::AutomorphismKey,
div_ceil,
keyswitch_key::GLWESwitchingKey, keyswitch_key::GLWESwitchingKey,
test_fft64::{log2_std_noise_gglwe_product, noise_ggsw_product}, test_fft64::{log2_std_noise_gglwe_product, noise_ggsw_product},
}; };
@@ -45,7 +44,7 @@ fn keyswitch() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_in: usize = 45; let k_in: usize = 45;
let digits: usize = div_ceil(k_in, basek); let digits: usize = k_in.div_ceil(basek);
(1..4).for_each(|rank_in| { (1..4).for_each(|rank_in| {
(1..4).for_each(|rank_out| { (1..4).for_each(|rank_out| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
@@ -66,7 +65,7 @@ fn keyswitch_inplace() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_ct: usize = 45; let k_ct: usize = 45;
let digits: usize = div_ceil(k_ct, basek); let digits: usize = k_ct.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
let k_ksk: usize = k_ct + basek * di; let k_ksk: usize = k_ct + basek * di;
@@ -81,7 +80,7 @@ fn external_product() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_in: usize = 45; let k_in: usize = 45;
let digits: usize = div_ceil(k_in, basek); let digits: usize = k_in.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
let k_ggsw: usize = k_in + basek * di; let k_ggsw: usize = k_in + basek * di;
@@ -97,7 +96,7 @@ fn external_product_inplace() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_ct: usize = 60; let k_ct: usize = 60;
let digits: usize = div_ceil(k_ct, basek); let digits: usize = k_ct.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
let k_ggsw: usize = k_ct + basek * di; let k_ggsw: usize = k_ct + basek * di;
@@ -112,7 +111,7 @@ fn automorphism_inplace() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_ct: usize = 60; let k_ct: usize = 60;
let digits: usize = div_ceil(k_ct, basek); let digits: usize = k_ct.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
let k_ksk: usize = k_ct + basek * di; let k_ksk: usize = k_ct + basek * di;
@@ -127,7 +126,7 @@ fn automorphism() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_in: usize = 60; let k_in: usize = 60;
let digits: usize = div_ceil(k_in, basek); let digits: usize = k_in.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
let k_ksk: usize = k_in + basek * di; let k_ksk: usize = k_in + basek * di;
@@ -299,7 +298,7 @@ fn test_keyswitch(
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_in, basek * digits); let rows: usize = k_in.div_ceil(basek * digits);
let mut ksk: GLWESwitchingKey<Vec<u8>, FFT64> = let mut ksk: GLWESwitchingKey<Vec<u8>, FFT64> =
GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, digits, rank_in, rank_out); GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, digits, rank_in, rank_out);
@@ -390,7 +389,7 @@ fn test_keyswitch(
fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ct: usize, k_ksk: usize, digits: usize, rank: usize, sigma: f64) { fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ct: usize, k_ksk: usize, digits: usize, rank: usize, sigma: f64) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_ct, basek * digits); let rows: usize = k_ct.div_ceil(basek * digits);
let mut ct_grlwe: GLWESwitchingKey<Vec<u8>, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, digits, rank, rank); let mut ct_grlwe: GLWESwitchingKey<Vec<u8>, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, digits, rank, rank);
let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank); let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank);
@@ -479,7 +478,7 @@ fn test_automorphism(
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_in, basek * digits); let rows: usize = k_in.div_ceil(basek * digits);
let mut autokey: AutomorphismKey<Vec<u8>, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, digits, rank); let mut autokey: AutomorphismKey<Vec<u8>, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, digits, rank);
let mut ct_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_in, rank); let mut ct_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_in, rank);
@@ -576,7 +575,7 @@ fn test_automorphism_inplace(
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_ct, basek * digits); let rows: usize = k_ct.div_ceil(basek * digits);
let mut autokey: AutomorphismKey<Vec<u8>, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, digits, rank); let mut autokey: AutomorphismKey<Vec<u8>, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, digits, rank);
let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank); let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank);
@@ -661,7 +660,7 @@ fn test_external_product(
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_in, digits * basek); let rows: usize = k_in.div_ceil(basek * digits);
let mut ct_ggsw: GGSWCiphertext<Vec<u8>, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, digits, rank); let mut ct_ggsw: GGSWCiphertext<Vec<u8>, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, digits, rank);
let mut ct_glwe_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_in, rank); let mut ct_glwe_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_in, rank);
@@ -764,7 +763,7 @@ fn test_external_product(
fn test_external_product_inplace(log_n: usize, basek: usize, k_ct: usize, k_ggsw: usize, digits: usize, rank: usize, sigma: f64) { fn test_external_product_inplace(log_n: usize, basek: usize, k_ct: usize, k_ggsw: usize, digits: usize, rank: usize, sigma: f64) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_ct, digits * basek); let rows: usize = k_ct.div_ceil(basek * digits);
let mut ct_ggsw: GGSWCiphertext<Vec<u8>, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, digits, rank); let mut ct_ggsw: GGSWCiphertext<Vec<u8>, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, digits, rank);
let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank); let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank);

18
core/src/test_fft64/glwe_fourier.rs
View File

@@ -1,5 +1,5 @@
use crate::{ use crate::{
GGSWCiphertext, GLWECiphertext, GLWECiphertextFourier, GLWEOps, GLWEPlaintext, GLWESecret, GLWESwitchingKey, Infos, div_ceil, GGSWCiphertext, GLWECiphertext, GLWECiphertextFourier, GLWEOps, GLWEPlaintext, GLWESecret, GLWESwitchingKey, Infos,
test_fft64::{log2_std_noise_gglwe_product, noise_ggsw_product}, test_fft64::{log2_std_noise_gglwe_product, noise_ggsw_product},
}; };
use backend::{FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, ZnxViewMut}; use backend::{FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, ZnxViewMut};
@@ -10,7 +10,7 @@ fn keyswitch() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_in: usize = 45; let k_in: usize = 45;
let digits: usize = div_ceil(k_in, basek); let digits: usize = k_in.div_ceil(basek);
(1..4).for_each(|rank_in| { (1..4).for_each(|rank_in| {
(1..4).for_each(|rank_out| { (1..4).for_each(|rank_out| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
@@ -31,7 +31,7 @@ fn keyswitch_inplace() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_ct: usize = 45; let k_ct: usize = 45;
let digits: usize = div_ceil(k_ct, basek); let digits: usize = k_ct.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
let k_ksk: usize = k_ct + basek * di; let k_ksk: usize = k_ct + basek * di;
@@ -46,7 +46,7 @@ fn external_product() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_in: usize = 45; let k_in: usize = 45;
let digits: usize = div_ceil(k_in, basek); let digits: usize = k_in.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
let k_ggsw: usize = k_in + basek * di; let k_ggsw: usize = k_in + basek * di;
@@ -62,7 +62,7 @@ fn external_product_inplace() {
let log_n: usize = 8; let log_n: usize = 8;
let basek: usize = 12; let basek: usize = 12;
let k_ct: usize = 60; let k_ct: usize = 60;
let digits: usize = div_ceil(k_ct, basek); let digits: usize = k_ct.div_ceil(basek);
(1..4).for_each(|rank| { (1..4).for_each(|rank| {
(1..digits + 1).for_each(|di| { (1..digits + 1).for_each(|di| {
let k_ggsw: usize = k_ct + basek * di; let k_ggsw: usize = k_ct + basek * di;
@@ -85,7 +85,7 @@ fn test_keyswitch(
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_in, basek * digits); let rows: usize = k_in.div_ceil(basek * digits);
let mut ksk: GLWESwitchingKey<Vec<u8>, FFT64> = let mut ksk: GLWESwitchingKey<Vec<u8>, FFT64> =
GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, digits, rank_in, rank_out); GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, digits, rank_in, rank_out);
@@ -181,7 +181,7 @@ fn test_keyswitch(
fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ct: usize, k_ksk: usize, digits: usize, rank: usize, sigma: f64) { fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ct: usize, k_ksk: usize, digits: usize, rank: usize, sigma: f64) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_ct, basek * digits); let rows: usize = k_ct.div_ceil(basek * digits);
let mut ksk: GLWESwitchingKey<Vec<u8>, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, digits, rank, rank); let mut ksk: GLWESwitchingKey<Vec<u8>, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, digits, rank, rank);
let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank); let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank);
@@ -273,7 +273,7 @@ fn test_external_product(
) { ) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_in, digits * basek); let rows: usize = k_in.div_ceil(basek * digits);
let mut ct_ggsw: GGSWCiphertext<Vec<u8>, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, digits, rank); let mut ct_ggsw: GGSWCiphertext<Vec<u8>, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, digits, rank);
let mut ct_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_in, rank); let mut ct_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_in, rank);
@@ -380,7 +380,7 @@ fn test_external_product(
fn test_external_product_inplace(log_n: usize, basek: usize, k_ct: usize, k_ggsw: usize, digits: usize, rank: usize, sigma: f64) { fn test_external_product_inplace(log_n: usize, basek: usize, k_ct: usize, k_ggsw: usize, digits: usize, rank: usize, sigma: f64) {
let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n); let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
let rows: usize = div_ceil(k_ct, digits * basek); let rows: usize = k_ct.div_ceil(basek * digits);
let mut ct_ggsw: GGSWCiphertext<Vec<u8>, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, digits, rank); let mut ct_ggsw: GGSWCiphertext<Vec<u8>, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, digits, rank);
let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank); let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank);

4
core/src/test_fft64/glwe_packing.rs
View File

@@ -1,4 +1,4 @@
use crate::{AutomorphismKey, GLWECiphertext, GLWEOps, GLWEPlaintext, GLWESecret, StreamPacker, div_ceil}; use crate::{AutomorphismKey, GLWECiphertext, GLWEOps, GLWEPlaintext, GLWESecret, StreamPacker};
use std::collections::HashMap; use std::collections::HashMap;
use backend::{Encoding, FFT64, Module, ScratchOwned, Stats}; use backend::{Encoding, FFT64, Module, ScratchOwned, Stats};
@@ -21,7 +21,7 @@ fn packing() {
let digits: usize = 1; let digits: usize = 1;
let k_ksk: usize = k_ct + basek * digits; let k_ksk: usize = k_ct + basek * digits;
let rows: usize = div_ceil(k_ct, basek * digits); let rows: usize = k_ct.div_ceil(basek * digits);
let mut scratch: ScratchOwned = ScratchOwned::new( let mut scratch: ScratchOwned = ScratchOwned::new(
GLWECiphertext::encrypt_sk_scratch_space(&module, basek, k_ct) GLWECiphertext::encrypt_sk_scratch_space(&module, basek, k_ct)

4
core/src/test_fft64/trace.rs
View File

@@ -3,7 +3,7 @@ use std::collections::HashMap;
use backend::{FFT64, FillUniform, Module, ScratchOwned, Stats, VecZnxOps, ZnxView, ZnxViewMut}; use backend::{FFT64, FillUniform, Module, ScratchOwned, Stats, VecZnxOps, ZnxView, ZnxViewMut};
use sampling::source::Source; use sampling::source::Source;
use crate::{AutomorphismKey, GLWECiphertext, GLWEPlaintext, GLWESecret, Infos, div_ceil, test_fft64::var_noise_gglwe_product}; use crate::{AutomorphismKey, GLWECiphertext, GLWEPlaintext, GLWESecret, Infos, test_fft64::var_noise_gglwe_product};
#[test] #[test]
fn trace_inplace() { fn trace_inplace() {
@@ -20,7 +20,7 @@ fn test_trace_inplace(log_n: usize, basek: usize, k: usize, sigma: f64, rank: us
let k_autokey: usize = k + basek; let k_autokey: usize = k + basek;
let digits: usize = 1; let digits: usize = 1;
let rows: usize = div_ceil(k, digits * basek); let rows: usize = k.div_ceil(basek * digits);
let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k, rank); let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k, rank);
let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&module, basek, k); let mut pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&module, basek, k);

3
core/src/utils.rs
View File

@@ -1,3 +0,0 @@
pub(crate) fn div_ceil(a: usize, b: usize) -> usize {
(a + b - 1) / b
}