Add Zn type

poulpy-hal/src/api/mod.rs

@@ -5,6 +5,7 @@ mod vec_znx;
 mod vec_znx_big;
 mod vec_znx_dft;
 mod vmp_pmat;
+mod zn;
 mod znx_base;
 
 pub use module::*;
@@ -14,4 +15,5 @@ pub use vec_znx::*;
 pub use vec_znx_big::*;
 pub use vec_znx_dft::*;
 pub use vmp_pmat::*;
+pub use zn::*;
 pub use znx_base::*;

poulpy-hal/src/api/svp_ppol.rs

@@ -2,18 +2,18 @@ use crate::layouts::{Backend, ScalarZnxToRef, SvpPPolOwned, SvpPPolToMut, SvpPPo
 
 /// Allocates as [crate::layouts::SvpPPol].
 pub trait SvpPPolAlloc<B: Backend> {
-    fn svp_ppol_alloc(&self, n: usize, cols: usize) -> SvpPPolOwned<B>;
+    fn svp_ppol_alloc(&self, cols: usize) -> SvpPPolOwned<B>;
 }
 
 /// Returns the size in bytes to allocate a [crate::layouts::SvpPPol].
 pub trait SvpPPolAllocBytes {
-    fn svp_ppol_alloc_bytes(&self, n: usize, cols: usize) -> usize;
+    fn svp_ppol_alloc_bytes(&self, cols: usize) -> usize;
 }
 
 /// Consume a vector of bytes into a [crate::layouts::MatZnx].
 /// User must ensure that bytes is memory aligned and that it length is equal to [SvpPPolAllocBytes].
 pub trait SvpPPolFromBytes<B: Backend> {
-    fn svp_ppol_from_bytes(&self, n: usize, cols: usize, bytes: Vec<u8>) -> SvpPPolOwned<B>;
+    fn svp_ppol_from_bytes(&self, cols: usize, bytes: Vec<u8>) -> SvpPPolOwned<B>;
 }
 
 /// Prepare a [crate::layouts::ScalarZnx] into an [crate::layouts::SvpPPol].

poulpy-hal/src/api/vec_znx.rs

@@ -7,7 +7,7 @@ use crate::{
 
 pub trait VecZnxNormalizeTmpBytes {
     /// Returns the minimum number of bytes necessary for normalization.
-    fn vec_znx_normalize_tmp_bytes(&self, n: usize) -> usize;
+    fn vec_znx_normalize_tmp_bytes(&self) -> usize;
 }
 
 pub trait VecZnxNormalize<B: Backend> {

poulpy-hal/src/api/vec_znx_big.rs

@@ -7,18 +7,18 @@ use crate::{
 
 /// Allocates as [crate::layouts::VecZnxBig].
 pub trait VecZnxBigAlloc<B: Backend> {
-    fn vec_znx_big_alloc(&self, n: usize, cols: usize, size: usize) -> VecZnxBigOwned<B>;
+    fn vec_znx_big_alloc(&self, cols: usize, size: usize) -> VecZnxBigOwned<B>;
 }
 
 /// Returns the size in bytes to allocate a [crate::layouts::VecZnxBig].
 pub trait VecZnxBigAllocBytes {
-    fn vec_znx_big_alloc_bytes(&self, n: usize, cols: usize, size: usize) -> usize;
+    fn vec_znx_big_alloc_bytes(&self, cols: usize, size: usize) -> usize;
 }
 
 /// Consume a vector of bytes into a [crate::layouts::VecZnxBig].
 /// User must ensure that bytes is memory aligned and that it length is equal to [VecZnxBigAllocBytes].
 pub trait VecZnxBigFromBytes<B: Backend> {
-    fn vec_znx_big_from_bytes(&self, n: usize, cols: usize, size: usize, bytes: Vec<u8>) -> VecZnxBigOwned<B>;
+    fn vec_znx_big_from_bytes(&self, cols: usize, size: usize, bytes: Vec<u8>) -> VecZnxBigOwned<B>;
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -187,7 +187,7 @@ pub trait VecZnxBigNegateInplace<B: Backend> {
 }
 
 pub trait VecZnxBigNormalizeTmpBytes {
-    fn vec_znx_big_normalize_tmp_bytes(&self, n: usize) -> usize;
+    fn vec_znx_big_normalize_tmp_bytes(&self) -> usize;
 }
 
 pub trait VecZnxBigNormalize<B: Backend> {

poulpy-hal/src/api/vec_znx_dft.rs

@@ -3,19 +3,19 @@ use crate::layouts::{
 };
 
 pub trait VecZnxDftAlloc<B: Backend> {
-    fn vec_znx_dft_alloc(&self, n: usize, cols: usize, size: usize) -> VecZnxDftOwned<B>;
+    fn vec_znx_dft_alloc(&self, cols: usize, size: usize) -> VecZnxDftOwned<B>;
 }
 
 pub trait VecZnxDftFromBytes<B: Backend> {
-    fn vec_znx_dft_from_bytes(&self, n: usize, cols: usize, size: usize, bytes: Vec<u8>) -> VecZnxDftOwned<B>;
+    fn vec_znx_dft_from_bytes(&self, cols: usize, size: usize, bytes: Vec<u8>) -> VecZnxDftOwned<B>;
 }
 
 pub trait VecZnxDftAllocBytes {
-    fn vec_znx_dft_alloc_bytes(&self, n: usize, cols: usize, size: usize) -> usize;
+    fn vec_znx_dft_alloc_bytes(&self, cols: usize, size: usize) -> usize;
 }
 
 pub trait VecZnxDftToVecZnxBigTmpBytes {
-    fn vec_znx_dft_to_vec_znx_big_tmp_bytes(&self, n: usize) -> usize;
+    fn vec_znx_dft_to_vec_znx_big_tmp_bytes(&self) -> usize;
 }
 
 pub trait VecZnxDftToVecZnxBig<B: Backend> {

poulpy-hal/src/api/vmp_pmat.rs

@@ -1,27 +1,19 @@
 use crate::layouts::{Backend, MatZnxToRef, Scratch, VecZnxDftToMut, VecZnxDftToRef, VmpPMatOwned, VmpPMatToMut, VmpPMatToRef};
 
 pub trait VmpPMatAlloc<B: Backend> {
-    fn vmp_pmat_alloc(&self, n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> VmpPMatOwned<B>;
+    fn vmp_pmat_alloc(&self, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> VmpPMatOwned<B>;
 }
 
 pub trait VmpPMatAllocBytes {
-    fn vmp_pmat_alloc_bytes(&self, n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize;
+    fn vmp_pmat_alloc_bytes(&self, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize;
 }
 
 pub trait VmpPMatFromBytes<B: Backend> {
-    fn vmp_pmat_from_bytes(
-        &self,
-        n: usize,
-        rows: usize,
-        cols_in: usize,
-        cols_out: usize,
-        size: usize,
-        bytes: Vec<u8>,
-    ) -> VmpPMatOwned<B>;
+    fn vmp_pmat_from_bytes(&self, rows: usize, cols_in: usize, cols_out: usize, size: usize, bytes: Vec<u8>) -> VmpPMatOwned<B>;
 }
 
 pub trait VmpPrepareTmpBytes {
-    fn vmp_prepare_tmp_bytes(&self, n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize;
+    fn vmp_prepare_tmp_bytes(&self, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize;
 }
 
 pub trait VmpPrepare<B: Backend> {
@@ -35,7 +27,6 @@ pub trait VmpPrepare<B: Backend> {
 pub trait VmpApplyTmpBytes {
     fn vmp_apply_tmp_bytes(
         &self,
-        n: usize,
         res_size: usize,
         a_size: usize,
         b_rows: usize,
@@ -81,7 +72,6 @@ pub trait VmpApply<B: Backend> {
 pub trait VmpApplyAddTmpBytes {
     fn vmp_apply_add_tmp_bytes(
         &self,
-        n: usize,
         res_size: usize,
         a_size: usize,
         b_rows: usize,

poulpy-hal/src/api/zn.rs

@@ -0,0 +1,86 @@
+use rand_distr::Distribution;
+
+use crate::{
+    layouts::{Backend, Scratch, ZnToMut},
+    source::Source,
+};
+
+pub trait ZnNormalizeInplace<B: Backend> {
+    /// Normalizes the selected column of `a`.
+    fn zn_normalize_inplace<A>(&self, n: usize, basek: usize, a: &mut A, a_col: usize, scratch: &mut Scratch<B>)
+    where
+        A: ZnToMut;
+}
+
+pub trait ZnFillUniform {
+    /// Fills the first `size` size with uniform values in \[-2^{basek-1}, 2^{basek-1}\]
+    fn zn_fill_uniform<R>(&self, n: usize, basek: usize, res: &mut R, res_col: usize, k: usize, source: &mut Source)
+    where
+        R: ZnToMut;
+}
+
+#[allow(clippy::too_many_arguments)]
+pub trait ZnFillDistF64 {
+    fn zn_fill_dist_f64<R, D: Distribution<f64>>(
+        &self,
+        n: usize,
+        basek: usize,
+        res: &mut R,
+        res_col: usize,
+        k: usize,
+        source: &mut Source,
+        dist: D,
+        bound: f64,
+    ) where
+        R: ZnToMut;
+}
+
+#[allow(clippy::too_many_arguments)]
+pub trait ZnAddDistF64 {
+    /// Adds vector sampled according to the provided distribution, scaled by 2^{-k} and bounded to \[-bound, bound\].
+    fn zn_add_dist_f64<R, D: Distribution<f64>>(
+        &self,
+        n: usize,
+        basek: usize,
+        res: &mut R,
+        res_col: usize,
+        k: usize,
+        source: &mut Source,
+        dist: D,
+        bound: f64,
+    ) where
+        R: ZnToMut;
+}
+
+#[allow(clippy::too_many_arguments)]
+pub trait ZnFillNormal {
+    fn zn_fill_normal<R>(
+        &self,
+        n: usize,
+        basek: usize,
+        res: &mut R,
+        res_col: usize,
+        k: usize,
+        source: &mut Source,
+        sigma: f64,
+        bound: f64,
+    ) where
+        R: ZnToMut;
+}
+
+#[allow(clippy::too_many_arguments)]
+pub trait ZnAddNormal {
+    /// Adds a discrete normal vector scaled by 2^{-k} with the provided standard deviation and bounded to \[-bound, bound\].
+    fn zn_add_normal<R>(
+        &self,
+        n: usize,
+        basek: usize,
+        res: &mut R,
+        res_col: usize,
+        k: usize,
+        source: &mut Source,
+        sigma: f64,
+        bound: f64,
+    ) where
+        R: ZnToMut;
+}