poulpy · arnaucube's git mirror

@@ -1,6 +1,6 @@
 use backend::{Backend, Module, ZnxInfos};
 
-use crate::{GLWECiphertextFourier, div_ceil};
+use crate::GLWECiphertextFourier;
 
 pub trait Infos {
     type Inner: ZnxInfos;
@@ -34,7 +34,7 @@
     /// Returns the number of size per polynomial.
     fn size(&self) -> usize {
         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
     }

M core/src/gglwe_ciphertext.rs → core/src/gglwe_ciphertext.rs

@@ -4,7 +4,7 @@ ZnxInfos, ZnxZero,
 };
 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(crate) data: MatZnxDft<C, B>,
@@ -23,7 +23,7 @@ digits: usize,
         rank_in: usize,
         rank_out: usize,
     ) -> Self {
-        let size: usize = div_ceil(k, basek);
+        let size: usize = k.div_ceil(basek);
         debug_assert!(
             size > digits,
             "invalid gglwe: ceil(k/basek): {} <= digits: {}",
@@ -56,7 +56,7 @@ digits: usize,
         rank_in: usize,
         rank_out: usize,
     ) -> usize {
-        let size: usize = div_ceil(k, basek);
+        let size: usize = k.div_ceil(basek);
         debug_assert!(
             size > digits,
             "invalid gglwe: ceil(k/basek): {} <= digits: {}",
@@ -112,7 +112,7 @@ }
 
 impl GGLWECiphertext<Vec<u8>, FFT64> {
     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)
             + module.bytes_of_vec_znx(rank + 1, size)
             + module.bytes_of_vec_znx(1, size)

M core/src/ggsw_ciphertext.rs → core/src/ggsw_ciphertext.rs

@@ -7,7 +7,7 @@ use sampling::source::Source;
 
 use crate::{
     AutomorphismKey, GLWECiphertext, GLWECiphertextFourier, GLWESecret, GLWESwitchingKey, GetRow, Infos, ScratchCore, SetRow,
-    TensorKey, div_ceil,
+    TensorKey,
 };
 
 pub struct GGSWCiphertext<C, B: Backend> {
@@ -19,7 +19,7 @@ }
 
 impl<B: Backend> GGSWCiphertext<Vec<u8>, B> {
     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!(
             size > digits,
             "invalid ggsw: ceil(k/basek): {} <= digits: {}",
@@ -36,7 +36,7 @@ size
         );
 
         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,
             k: k,
             digits,
@@ -44,7 +44,7 @@ }
     }
 
     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!(
             size > digits,
             "invalid ggsw: ceil(k/basek): {} <= digits: {}",
@@ -92,7 +92,7 @@ }
 
 impl GGSWCiphertext<Vec<u8>, FFT64> {
     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)
             + module.bytes_of_vec_znx(rank + 1, size)
             + module.bytes_of_vec_znx(1, size)
@@ -107,9 +107,9 @@ k_tsk: usize,
         digits: usize,
         rank: usize,
     ) -> usize {
-        let tsk_size: usize = div_ceil(k_tsk, basek);
-        let self_size_out: usize = div_ceil(self_k, basek);
-        let self_size_in: usize = div_ceil(self_size_out, digits);
+        let tsk_size: usize = k_tsk.div_ceil(basek);
+        let self_size_out: usize = self_k.div_ceil(basek);
+        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_a: usize = module.bytes_of_vec_znx_dft(1, self_size_in);
         let vmp: usize = module.vmp_apply_tmp_bytes(
@@ -135,7 +135,7 @@ digits: usize,
         rank: usize,
     ) -> usize {
         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(
@@ -149,8 +149,7 @@ k_tsk: usize,
         digits_tsk: usize,
         rank: 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 ci_dft: usize = module.bytes_of_vec_znx_dft(rank + 1, out_size);
         let ks: usize =
@@ -187,7 +186,7 @@ digits_tsk: usize,
         rank: usize,
     ) -> usize {
         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_dft: usize = module.bytes_of_vec_znx_dft(cols, out_size);
         let ci_dft: usize = module.bytes_of_vec_znx_dft(cols, out_size);

M core/src/glwe_ciphertext.rs → core/src/glwe_ciphertext.rs

@@ -7,7 +7,7 @@ use sampling::source::Source;
 
 use crate::{
     AutomorphismKey, GGSWCiphertext, GLWECiphertextFourier, GLWEOps, GLWEPlaintext, GLWEPublicKey, GLWESecret, GLWESwitchingKey,
-    Infos, SIX_SIGMA, SecretDistribution, SetMetaData, div_ceil,
+    Infos, SIX_SIGMA, SecretDistribution, SetMetaData,
 };
 
 pub struct GLWECiphertext<C> {
@@ -19,14 +19,14 @@
 impl GLWECiphertext<Vec<u8>> {
     pub fn alloc<B: Backend>(module: &Module<B>, basek: usize, k: usize, rank: usize) -> 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,
             k,
         }
     }
 
     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 GLWECiphertext<Vec<u8>> {
     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)
     }
     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_scalar_znx_dft(1)
             + module.vec_znx_big_normalize_tmp_bytes()
     }
 
     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)
     }
 
@@ -95,9 +95,9 @@ rank_in: usize,
         rank_out: usize,
     ) -> usize {
         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 out_size: usize = div_ceil(k_out, basek);
-        let ksk_size: usize = div_ceil(k_ksk, basek);
+        let in_size: usize = k_in.div_ceil(basek).div_ceil(digits);
+        let out_size: usize = k_out.div_ceil(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 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);
@@ -162,9 +162,9 @@ digits: usize,
         rank: usize,
     ) -> usize {
         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 out_size: usize = div_ceil(k_out, basek);
-        let ggsw_size: usize = div_ceil(ggsw_k, basek);
+        let in_size: usize = k_in.div_ceil(basek).div_ceil(digits);
+        let out_size: usize = k_out.div_ceil(basek);
+        let ggsw_size: usize = ggsw_k.div_ceil(basek);
         let vmp: usize = module.bytes_of_vec_znx_dft(rank + 1, in_size)
             + module.vmp_apply_tmp_bytes(
                 out_size,

M core/src/glwe_ciphertext_fourier.rs → core/src/glwe_ciphertext_fourier.rs

@@ -4,7 +4,7 @@ VecZnxBigOps, VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, ZnxZero,
 };
 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 data: VecZnxDft<C, B>,
@@ -15,14 +15,14 @@
 impl<B: Backend> GLWECiphertextFourier<Vec<u8>, B> {
     pub fn alloc(module: &Module<B>, basek: usize, k: usize, rank: usize) -> 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,
             k: k,
         }
     }
 
     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 GLWECiphertextFourier<Vec<u8>, FFT64> {
     #[allow(dead_code)]
     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())
     }
 
     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 {
-        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_idft_tmp_bytes()))
@@ -102,10 +102,10 @@ k_ggsw: usize,
         digits: usize,
         rank: 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 in_size: usize = div_ceil(div_ceil(k_in, basek), digits);
-        let ggsw_size: usize = div_ceil(k_ggsw, basek);
+        let in_size: usize = k_in.div_ceil(basek).div_ceil(digits);
+        let ggsw_size: usize = k_ggsw.div_ceil(basek);
         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);
         let res_small: usize = module.bytes_of_vec_znx(rank + 1, ggsw_size);

M core/src/glwe_plaintext.rs → core/src/glwe_plaintext.rs

@@ -1,6 +1,6 @@
 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 data: VecZnx<C>,
@@ -37,14 +37,14 @@
 impl GLWEPlaintext<Vec<u8>> {
     pub fn alloc<B: Backend>(module: &Module<B>, basek: usize, k: usize) -> Self {
         Self {
-            data: module.new_vec_znx(1, div_ceil(k, basek)),
+            data: module.new_vec_znx(1, k.div_ceil(basek)),
             basek: basek,
             k,
         }
     }
 
     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))
     }
 }

M core/src/lib.rs → core/src/lib.rs

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

M core/src/test_fft64/automorphism_key.rs → core/src/test_fft64/automorphism_key.rs

@@ -2,8 +2,7 @@ use backend::{FFT64, Module, ScalarZnxOps, ScratchOwned, Stats, VecZnxOps};
 use sampling::source::Source;
 
 use crate::{
-    AutomorphismKey, GLWECiphertextFourier, GLWEPlaintext, GLWESecret, GetRow, Infos, div_ceil,
-    test_fft64::log2_std_noise_gglwe_product,
+    AutomorphismKey, GLWECiphertextFourier, GLWEPlaintext, GLWESecret, GetRow, Infos, test_fft64::log2_std_noise_gglwe_product,
 };
 
 #[test]
@@ -12,7 +11,7 @@ let log_n: usize = 8;
     let basek: usize = 12;
     let k_in: 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;
     (1..4).for_each(|rank| {
         (2..digits + 1).for_each(|di| {
@@ -28,7 +27,7 @@ fn automorphism_inplace() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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;
     (1..4).for_each(|rank| {
         (2..digits + 1).for_each(|di| {
@@ -56,7 +55,7 @@
     let digits_in: usize = 1;
 
     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_out: AutomorphismKey<Vec<u8>, FFT64> =
@@ -172,7 +171,7 @@
     let digits_in: usize = 1;
 
     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_apply: AutomorphismKey<Vec<u8>, FFT64> =

M core/src/test_fft64/gglwe.rs → core/src/test_fft64/gglwe.rs

@@ -2,7 +2,7 @@ use backend::{FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxToMut, ScratchOwned, Stats, VecZnxOps, ZnxViewMut};
 use sampling::source::Source;
 
 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},
 };
 
@@ -30,7 +30,7 @@ fn key_switch() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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_out_s0s1| {
             (1..4).for_each(|rank_out_s1s2| {
@@ -64,7 +64,7 @@ fn key_switch_inplace() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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_out_s0s1| {
             (1..digits + 1).for_each(|di| {
@@ -93,7 +93,7 @@ fn external_product() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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_out| {
             (1..digits + 1).for_each(|di| {
@@ -116,7 +116,7 @@ fn external_product_inplace() {
     let log_n: usize = 5;
     let basek: usize = 12;
     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_out| {
             (1..digits).for_each(|di| {
@@ -197,7 +197,7 @@ rank_out_s1s2: usize,
     sigma: f64,
 ) {
     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 mut ct_gglwe_s0s1: GLWESwitchingKey<Vec<u8>, FFT64> = GLWESwitchingKey::alloc(
@@ -332,7 +332,7 @@ rank_out: usize,
     sigma: f64,
 ) {
     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 mut ct_gglwe_s0s1: GLWESwitchingKey<Vec<u8>, FFT64> =
@@ -438,7 +438,7 @@ sigma: f64,
 ) {
     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 mut ct_gglwe_in: GLWESwitchingKey<Vec<u8>, FFT64> =
@@ -559,7 +559,7 @@ sigma: f64,
 ) {
     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;

M core/src/test_fft64/ggsw.rs → core/src/test_fft64/ggsw.rs

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

M core/src/test_fft64/glwe.rs → core/src/test_fft64/glwe.rs

@@ -8,7 +8,6 @@
 use crate::{
     GGSWCiphertext, GLWECiphertext, GLWECiphertextFourier, GLWEPlaintext, GLWEPublicKey, GLWESecret, Infos,
     automorphism::AutomorphismKey,
-    div_ceil,
     keyswitch_key::GLWESwitchingKey,
     test_fft64::{log2_std_noise_gglwe_product, noise_ggsw_product},
 };
@@ -45,7 +44,7 @@ fn keyswitch() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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_out| {
             (1..digits + 1).for_each(|di| {
@@ -66,7 +65,7 @@ fn keyswitch_inplace() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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..digits + 1).for_each(|di| {
             let k_ksk: usize = k_ct + basek * di;
@@ -81,7 +80,7 @@ fn external_product() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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..digits + 1).for_each(|di| {
             let k_ggsw: usize = k_in + basek * di;
@@ -97,7 +96,7 @@ fn external_product_inplace() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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..digits + 1).for_each(|di| {
             let k_ggsw: usize = k_ct + basek * di;
@@ -112,7 +111,7 @@ fn automorphism_inplace() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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..digits + 1).for_each(|di| {
             let k_ksk: usize = k_ct + basek * di;
@@ -127,7 +126,7 @@ fn automorphism() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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..digits + 1).for_each(|di| {
             let k_ksk: usize = k_in + basek * di;
@@ -299,7 +298,7 @@ sigma: f64,
 ) {
     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> =
         GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, digits, rank_in, rank_out);
@@ -390,7 +389,7 @@
 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 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_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank);
@@ -479,7 +478,7 @@ sigma: f64,
 ) {
     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 ct_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_in, rank);
@@ -576,7 +575,7 @@ sigma: f64,
 ) {
     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 ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank);
@@ -661,7 +660,7 @@ sigma: f64,
 ) {
     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_glwe_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_in, rank);
@@ -764,7 +763,7 @@ }
 
 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 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_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank);

M core/src/test_fft64/glwe_fourier.rs → core/src/test_fft64/glwe_fourier.rs

@@ -1,5 +1,5 @@
 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},
 };
 use backend::{FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, ZnxViewMut};
@@ -10,7 +10,7 @@ fn keyswitch() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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_out| {
             (1..digits + 1).for_each(|di| {
@@ -31,7 +31,7 @@ fn keyswitch_inplace() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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..digits + 1).for_each(|di| {
             let k_ksk: usize = k_ct + basek * di;
@@ -46,7 +46,7 @@ fn external_product() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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..digits + 1).for_each(|di| {
             let k_ggsw: usize = k_in + basek * di;
@@ -62,7 +62,7 @@ fn external_product_inplace() {
     let log_n: usize = 8;
     let basek: usize = 12;
     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..digits + 1).for_each(|di| {
             let k_ggsw: usize = k_ct + basek * di;
@@ -85,7 +85,7 @@ sigma: f64,
 ) {
     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> =
         GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, digits, rank_in, rank_out);
@@ -181,7 +181,7 @@
 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 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 ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank);
@@ -273,7 +273,7 @@ sigma: f64,
 ) {
     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_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_in, rank);
@@ -380,7 +380,7 @@ }
 
 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 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: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(&module, basek, k_ct, rank);

M core/src/test_fft64/glwe_packing.rs → core/src/test_fft64/glwe_packing.rs

@@ -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 backend::{Encoding, FFT64, Module, ScratchOwned, Stats};
@@ -21,7 +21,7 @@ let sigma: f64 = 3.2;
     let digits: usize = 1;
     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(
         GLWECiphertext::encrypt_sk_scratch_space(&module, basek, k_ct)

M core/src/test_fft64/trace.rs → core/src/test_fft64/trace.rs

@@ -3,7 +3,7 @@
 use backend::{FFT64, FillUniform, Module, ScratchOwned, Stats, VecZnxOps, ZnxView, ZnxViewMut};
 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]
 fn trace_inplace() {
@@ -20,7 +20,7 @@
     let k_autokey: usize = k + basek;
 
     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 pt_want: GLWEPlaintext<Vec<u8>> = GLWEPlaintext::alloc(&module, basek, k);

D core/src/utils.rs

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