Crates io (#76)

* crates re-organisation

* fixed typo in layout & added test for vmp_apply

* updated dependencies

poulpy-hal/src/api/mod.rs

@@ -0,0 +1,17 @@
+mod module;
+mod scratch;
+mod svp_ppol;
+mod vec_znx;
+mod vec_znx_big;
+mod vec_znx_dft;
+mod vmp_pmat;
+mod znx_base;
+
+pub use module::*;
+pub use scratch::*;
+pub use svp_ppol::*;
+pub use vec_znx::*;
+pub use vec_znx_big::*;
+pub use vec_znx_dft::*;
+pub use vmp_pmat::*;
+pub use znx_base::*;

poulpy-hal/src/api/module.rs

@@ -0,0 +1,6 @@
+use crate::layouts::Backend;
+
+/// Instantiate a new [crate::layouts::Module].
+pub trait ModuleNew<B: Backend> {
+    fn new(n: u64) -> Self;
+}

poulpy-hal/src/api/scratch.rs

@@ -0,0 +1,107 @@
+use crate::layouts::{Backend, MatZnx, ScalarZnx, Scratch, SvpPPol, VecZnx, VecZnxBig, VecZnxDft, VmpPMat};
+
+/// Allocates a new [crate::layouts::ScratchOwned] of `size` aligned bytes.
+pub trait ScratchOwnedAlloc<B: Backend> {
+    fn alloc(size: usize) -> Self;
+}
+
+/// Borrows a slice of bytes into a [Scratch].
+pub trait ScratchOwnedBorrow<B: Backend> {
+    fn borrow(&mut self) -> &mut Scratch<B>;
+}
+
+/// Wrap an array of mutable borrowed bytes into a [Scratch].
+pub trait ScratchFromBytes<B: Backend> {
+    fn from_bytes(data: &mut [u8]) -> &mut Scratch<B>;
+}
+
+/// Returns how many bytes left can be taken from the scratch.
+pub trait ScratchAvailable {
+    fn available(&self) -> usize;
+}
+
+/// Takes a slice of bytes from a [Scratch] and return a new [Scratch] minus the taken array of bytes.
+pub trait TakeSlice {
+    fn take_slice<T>(&mut self, len: usize) -> (&mut [T], &mut Self);
+}
+
+/// Take a slice of bytes from a [Scratch], wraps it into a [ScalarZnx] and returns it
+/// as well as a new [Scratch] minus the taken array of bytes.
+pub trait TakeScalarZnx {
+    fn take_scalar_znx(&mut self, n: usize, cols: usize) -> (ScalarZnx<&mut [u8]>, &mut Self);
+}
+
+/// Take a slice of bytes from a [Scratch], wraps it into a [SvpPPol] and returns it
+/// as well as a new [Scratch] minus the taken array of bytes.
+pub trait TakeSvpPPol<B: Backend> {
+    fn take_svp_ppol(&mut self, n: usize, cols: usize) -> (SvpPPol<&mut [u8], B>, &mut Self);
+}
+
+/// Take a slice of bytes from a [Scratch], wraps it into a [VecZnx] and returns it
+/// as well as a new [Scratch] minus the taken array of bytes.
+pub trait TakeVecZnx {
+    fn take_vec_znx(&mut self, n: usize, cols: usize, size: usize) -> (VecZnx<&mut [u8]>, &mut Self);
+}
+
+/// Take a slice of bytes from a [Scratch], slices it into a vector of [VecZnx] aand returns it
+/// as well as a new [Scratch] minus the taken array of bytes.
+pub trait TakeVecZnxSlice {
+    fn take_vec_znx_slice(&mut self, len: usize, n: usize, cols: usize, size: usize) -> (Vec<VecZnx<&mut [u8]>>, &mut Self);
+}
+
+/// Take a slice of bytes from a [Scratch], wraps it into a [VecZnxBig] and returns it
+/// as well as a new [Scratch] minus the taken array of bytes.
+pub trait TakeVecZnxBig<B: Backend> {
+    fn take_vec_znx_big(&mut self, n: usize, cols: usize, size: usize) -> (VecZnxBig<&mut [u8], B>, &mut Self);
+}
+
+/// Take a slice of bytes from a [Scratch], wraps it into a [VecZnxDft] and returns it
+/// as well as a new [Scratch] minus the taken array of bytes.
+pub trait TakeVecZnxDft<B: Backend> {
+    fn take_vec_znx_dft(&mut self, n: usize, cols: usize, size: usize) -> (VecZnxDft<&mut [u8], B>, &mut Self);
+}
+
+/// Take a slice of bytes from a [Scratch], slices it into a vector of [VecZnxDft] and returns it
+/// as well as a new [Scratch] minus the taken array of bytes.
+pub trait TakeVecZnxDftSlice<B: Backend> {
+    fn take_vec_znx_dft_slice(
+        &mut self,
+        len: usize,
+        n: usize,
+        cols: usize,
+        size: usize,
+    ) -> (Vec<VecZnxDft<&mut [u8], B>>, &mut Self);
+}
+
+/// Take a slice of bytes from a [Scratch], wraps it into a [VmpPMat] and returns it
+/// as well as a new [Scratch] minus the taken array of bytes.
+pub trait TakeVmpPMat<B: Backend> {
+    fn take_vmp_pmat(
+        &mut self,
+        n: usize,
+        rows: usize,
+        cols_in: usize,
+        cols_out: usize,
+        size: usize,
+    ) -> (VmpPMat<&mut [u8], B>, &mut Self);
+}
+
+/// Take a slice of bytes from a [Scratch], wraps it into a [MatZnx] and returns it
+/// as well as a new [Scratch] minus the taken array of bytes.
+pub trait TakeMatZnx {
+    fn take_mat_znx(
+        &mut self,
+        n: usize,
+        rows: usize,
+        cols_in: usize,
+        cols_out: usize,
+        size: usize,
+    ) -> (MatZnx<&mut [u8]>, &mut Self);
+}
+
+/// Take a slice of bytes from a [Scratch], wraps it into the template's type and returns it
+/// as well as a new [Scratch] minus the taken array of bytes.
+pub trait TakeLike<'a, B: Backend, T> {
+    type Output;
+    fn take_like(&'a mut self, template: &T) -> (Self::Output, &'a mut Self);
+}

poulpy-hal/src/api/svp_ppol.rs

@@ -0,0 +1,42 @@
+use crate::layouts::{Backend, ScalarZnxToRef, SvpPPolOwned, SvpPPolToMut, SvpPPolToRef, VecZnxDftToMut, VecZnxDftToRef};
+
+/// Allocates as [crate::layouts::SvpPPol].
+pub trait SvpPPolAlloc<B: Backend> {
+    fn svp_ppol_alloc(&self, n: usize, 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;
+}
+
+/// 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>;
+}
+
+/// Prepare a [crate::layouts::ScalarZnx] into an [crate::layouts::SvpPPol].
+pub trait SvpPrepare<B: Backend> {
+    fn svp_prepare<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: SvpPPolToMut<B>,
+        A: ScalarZnxToRef;
+}
+
+/// Apply a scalar-vector product between `a[a_col]` and `b[b_col]` and stores the result on `res[res_col]`.
+pub trait SvpApply<B: Backend> {
+    fn svp_apply<R, A, C>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize)
+    where
+        R: VecZnxDftToMut<B>,
+        A: SvpPPolToRef<B>,
+        C: VecZnxDftToRef<B>;
+}
+
+/// Apply a scalar-vector product between `res[res_col]` and `a[a_col]` and stores the result on `res[res_col]`.
+pub trait SvpApplyInplace<B: Backend> {
+    fn svp_apply_inplace<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxDftToMut<B>,
+        A: SvpPPolToRef<B>;
+}

poulpy-hal/src/api/vec_znx.rs

@@ -0,0 +1,269 @@
+use rand_distr::Distribution;
+
+use crate::{
+    layouts::{Backend, ScalarZnxToRef, Scratch, VecZnxToMut, VecZnxToRef},
+    source::Source,
+};
+
+pub trait VecZnxNormalizeTmpBytes {
+    /// Returns the minimum number of bytes necessary for normalization.
+    fn vec_znx_normalize_tmp_bytes(&self, n: usize) -> usize;
+}
+
+pub trait VecZnxNormalize<B: Backend> {
+    /// Normalizes the selected column of `a` and stores the result into the selected column of `res`.
+    fn vec_znx_normalize<R, A>(&self, basek: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxNormalizeInplace<B: Backend> {
+    /// Normalizes the selected column of `a`.
+    fn vec_znx_normalize_inplace<A>(&self, basek: usize, a: &mut A, a_col: usize, scratch: &mut Scratch<B>)
+    where
+        A: VecZnxToMut;
+}
+
+pub trait VecZnxAdd {
+    /// Adds the selected column of `a` to the selected column of `b` and writes the result on the selected column of `res`.
+    fn vec_znx_add<R, A, B>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &B, b_col: usize)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef,
+        B: VecZnxToRef;
+}
+
+pub trait VecZnxAddInplace {
+    /// Adds the selected column of `a` to the selected column of `res` and writes the result on the selected column of `res`.
+    fn vec_znx_add_inplace<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxAddScalarInplace {
+    /// Adds the selected column of `a` on the selected column and limb of `res`.
+    fn vec_znx_add_scalar_inplace<R, A>(&self, res: &mut R, res_col: usize, res_limb: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxToMut,
+        A: ScalarZnxToRef;
+}
+
+pub trait VecZnxSub {
+    /// Subtracts the selected column of `b` from the selected column of `a` and writes the result on the selected column of `res`.
+    fn vec_znx_sub<R, A, B>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &B, b_col: usize)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef,
+        B: VecZnxToRef;
+}
+
+pub trait VecZnxSubABInplace {
+    /// Subtracts the selected column of `a` from the selected column of `res` inplace.
+    ///
+    /// res\[res_col\] -= a\[a_col\]
+    fn vec_znx_sub_ab_inplace<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxSubBAInplace {
+    /// Subtracts the selected column of `res` from the selected column of `a` and inplace mutates `res`
+    ///
+    /// res\[res_col\] = a\[a_col\] - res\[res_col\]
+    fn vec_znx_sub_ba_inplace<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxSubScalarInplace {
+    /// Subtracts the selected column of `a` on the selected column and limb of `res`.
+    fn vec_znx_sub_scalar_inplace<R, A>(&self, res: &mut R, res_col: usize, res_limb: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxToMut,
+        A: ScalarZnxToRef;
+}
+
+pub trait VecZnxNegate {
+    // Negates the selected column of `a` and stores the result in `res_col` of `res`.
+    fn vec_znx_negate<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxNegateInplace {
+    /// Negates the selected column of `a`.
+    fn vec_znx_negate_inplace<A>(&self, a: &mut A, a_col: usize)
+    where
+        A: VecZnxToMut;
+}
+
+pub trait VecZnxLshInplace {
+    /// Left shift by k bits all columns of `a`.
+    fn vec_znx_lsh_inplace<A>(&self, basek: usize, k: usize, a: &mut A)
+    where
+        A: VecZnxToMut;
+}
+
+pub trait VecZnxRshInplace {
+    /// Right shift by k bits all columns of `a`.
+    fn vec_znx_rsh_inplace<A>(&self, basek: usize, k: usize, a: &mut A)
+    where
+        A: VecZnxToMut;
+}
+
+pub trait VecZnxRotate {
+    /// Multiplies the selected column of `a` by X^k and stores the result in `res_col` of `res`.
+    fn vec_znx_rotate<R, A>(&self, k: i64, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxRotateInplace {
+    /// Multiplies the selected column of `a` by X^k.
+    fn vec_znx_rotate_inplace<A>(&self, k: i64, a: &mut A, a_col: usize)
+    where
+        A: VecZnxToMut;
+}
+
+pub trait VecZnxAutomorphism {
+    /// Applies the automorphism X^i -> X^ik on the selected column of `a` and stores the result in `res_col` column of `res`.
+    fn vec_znx_automorphism<R, A>(&self, k: i64, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxAutomorphismInplace {
+    /// Applies the automorphism X^i -> X^ik on the selected column of `a`.
+    fn vec_znx_automorphism_inplace<A>(&self, k: i64, a: &mut A, a_col: usize)
+    where
+        A: VecZnxToMut;
+}
+
+pub trait VecZnxMulXpMinusOne {
+    fn vec_znx_mul_xp_minus_one<R, A>(&self, p: i64, r: &mut R, r_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxMulXpMinusOneInplace {
+    fn vec_znx_mul_xp_minus_one_inplace<R>(&self, p: i64, r: &mut R, r_col: usize)
+    where
+        R: VecZnxToMut;
+}
+
+pub trait VecZnxSplit<B: Backend> {
+    /// Splits the selected columns of `b` into subrings and copies them them into the selected column of `res`.
+    ///
+    /// # Panics
+    ///
+    /// This method requires that all [crate::layouts::VecZnx] of b have the same ring degree
+    /// and that b.n() * b.len() <= a.n()
+    fn vec_znx_split<R, A>(&self, res: &mut [R], res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxMerge {
+    /// Merges the subrings of the selected column of `a` into the selected column of `res`.
+    ///
+    /// # Panics
+    ///
+    /// This method requires that all [crate::layouts::VecZnx] of a have the same ring degree
+    /// and that a.n() * a.len() <= b.n()
+    fn vec_znx_merge<R, A>(&self, res: &mut R, res_col: usize, a: &[A], a_col: usize)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxSwithcDegree {
+    fn vec_znx_switch_degree<R, A>(&self, res: &mut R, res_col: usize, a: &A, col_a: usize)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxCopy {
+    fn vec_znx_copy<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxToMut,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxFillUniform {
+    /// Fills the first `size` size with uniform values in \[-2^{basek-1}, 2^{basek-1}\]
+    fn vec_znx_fill_uniform<R>(&self, basek: usize, res: &mut R, res_col: usize, k: usize, source: &mut Source)
+    where
+        R: VecZnxToMut;
+}
+
+#[allow(clippy::too_many_arguments)]
+pub trait VecZnxFillDistF64 {
+    fn vec_znx_fill_dist_f64<R, D: Distribution<f64>>(
+        &self,
+        basek: usize,
+        res: &mut R,
+        res_col: usize,
+        k: usize,
+        source: &mut Source,
+        dist: D,
+        bound: f64,
+    ) where
+        R: VecZnxToMut;
+}
+
+#[allow(clippy::too_many_arguments)]
+pub trait VecZnxAddDistF64 {
+    /// Adds vector sampled according to the provided distribution, scaled by 2^{-k} and bounded to \[-bound, bound\].
+    fn vec_znx_add_dist_f64<R, D: Distribution<f64>>(
+        &self,
+        basek: usize,
+        res: &mut R,
+        res_col: usize,
+        k: usize,
+        source: &mut Source,
+        dist: D,
+        bound: f64,
+    ) where
+        R: VecZnxToMut;
+}
+
+#[allow(clippy::too_many_arguments)]
+pub trait VecZnxFillNormal {
+    fn vec_znx_fill_normal<R>(
+        &self,
+        basek: usize,
+        res: &mut R,
+        res_col: usize,
+        k: usize,
+        source: &mut Source,
+        sigma: f64,
+        bound: f64,
+    ) where
+        R: VecZnxToMut;
+}
+
+#[allow(clippy::too_many_arguments)]
+pub trait VecZnxAddNormal {
+    /// Adds a discrete normal vector scaled by 2^{-k} with the provided standard deviation and bounded to \[-bound, bound\].
+    fn vec_znx_add_normal<R>(
+        &self,
+        basek: usize,
+        res: &mut R,
+        res_col: usize,
+        k: usize,
+        source: &mut Source,
+        sigma: f64,
+        bound: f64,
+    ) where
+        R: VecZnxToMut;
+}

poulpy-hal/src/api/vec_znx_big.rs

@@ -0,0 +1,220 @@
+use rand_distr::Distribution;
+
+use crate::{
+    layouts::{Backend, Scratch, VecZnxBigOwned, VecZnxBigToMut, VecZnxBigToRef, VecZnxToMut, VecZnxToRef},
+    source::Source,
+};
+
+/// Allocates as [crate::layouts::VecZnxBig].
+pub trait VecZnxBigAlloc<B: Backend> {
+    fn vec_znx_big_alloc(&self, n: usize, 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;
+}
+
+/// 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>;
+}
+
+#[allow(clippy::too_many_arguments)]
+/// Add a discrete normal distribution on res.
+///
+/// # Arguments
+/// * `basek`: base two logarithm of the bivariate representation
+/// * `res`: receiver.
+/// * `res_col`: column of the receiver on which the operation is performed/stored.
+/// * `k`:
+/// * `source`: random coin source.
+/// * `sigma`: standard deviation of the discrete normal distribution.
+/// * `bound`: rejection sampling bound.
+pub trait VecZnxBigAddNormal<B: Backend> {
+    fn vec_znx_big_add_normal<R: VecZnxBigToMut<B>>(
+        &self,
+        basek: usize,
+        res: &mut R,
+        res_col: usize,
+        k: usize,
+        source: &mut Source,
+        sigma: f64,
+        bound: f64,
+    );
+}
+
+#[allow(clippy::too_many_arguments)]
+pub trait VecZnxBigFillNormal<B: Backend> {
+    fn vec_znx_big_fill_normal<R: VecZnxBigToMut<B>>(
+        &self,
+        basek: usize,
+        res: &mut R,
+        res_col: usize,
+        k: usize,
+        source: &mut Source,
+        sigma: f64,
+        bound: f64,
+    );
+}
+
+#[allow(clippy::too_many_arguments)]
+pub trait VecZnxBigFillDistF64<B: Backend> {
+    fn vec_znx_big_fill_dist_f64<R: VecZnxBigToMut<B>, D: Distribution<f64>>(
+        &self,
+        basek: usize,
+        res: &mut R,
+        res_col: usize,
+        k: usize,
+        source: &mut Source,
+        dist: D,
+        bound: f64,
+    );
+}
+
+#[allow(clippy::too_many_arguments)]
+pub trait VecZnxBigAddDistF64<B: Backend> {
+    fn vec_znx_big_add_dist_f64<R: VecZnxBigToMut<B>, D: Distribution<f64>>(
+        &self,
+        basek: usize,
+        res: &mut R,
+        res_col: usize,
+        k: usize,
+        source: &mut Source,
+        dist: D,
+        bound: f64,
+    );
+}
+
+pub trait VecZnxBigAdd<B: Backend> {
+    /// Adds `a` to `b` and stores the result on `c`.
+    fn vec_znx_big_add<R, A, C>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxBigToRef<B>,
+        C: VecZnxBigToRef<B>;
+}
+
+pub trait VecZnxBigAddInplace<B: Backend> {
+    /// Adds `a` to `b` and stores the result on `b`.
+    fn vec_znx_big_add_inplace<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxBigToRef<B>;
+}
+
+pub trait VecZnxBigAddSmall<B: Backend> {
+    /// Adds `a` to `b` and stores the result on `c`.
+    fn vec_znx_big_add_small<R, A, C>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxBigToRef<B>,
+        C: VecZnxToRef;
+}
+
+pub trait VecZnxBigAddSmallInplace<B: Backend> {
+    /// Adds `a` to `b` and stores the result on `b`.
+    fn vec_znx_big_add_small_inplace<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxBigSub<B: Backend> {
+    /// Subtracts `a` to `b` and stores the result on `c`.
+    fn vec_znx_big_sub<R, A, C>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxBigToRef<B>,
+        C: VecZnxBigToRef<B>;
+}
+
+pub trait VecZnxBigSubABInplace<B: Backend> {
+    /// Subtracts `a` from `b` and stores the result on `b`.
+    fn vec_znx_big_sub_ab_inplace<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxBigToRef<B>;
+}
+
+pub trait VecZnxBigSubBAInplace<B: Backend> {
+    /// Subtracts `b` from `a` and stores the result on `b`.
+    fn vec_znx_big_sub_ba_inplace<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxBigToRef<B>;
+}
+
+pub trait VecZnxBigSubSmallA<B: Backend> {
+    /// Subtracts `b` from `a` and stores the result on `c`.
+    fn vec_znx_big_sub_small_a<R, A, C>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxToRef,
+        C: VecZnxBigToRef<B>;
+}
+
+pub trait VecZnxBigSubSmallAInplace<B: Backend> {
+    /// Subtracts `a` from `res` and stores the result on `res`.
+    fn vec_znx_big_sub_small_a_inplace<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxBigSubSmallB<B: Backend> {
+    /// Subtracts `b` from `a` and stores the result on `c`.
+    fn vec_znx_big_sub_small_b<R, A, C>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxBigToRef<B>,
+        C: VecZnxToRef;
+}
+
+pub trait VecZnxBigSubSmallBInplace<B: Backend> {
+    /// Subtracts `res` from `a` and stores the result on `res`.
+    fn vec_znx_big_sub_small_b_inplace<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxBigNegateInplace<B: Backend> {
+    fn vec_znx_big_negate_inplace<A>(&self, a: &mut A, a_col: usize)
+    where
+        A: VecZnxBigToMut<B>;
+}
+
+pub trait VecZnxBigNormalizeTmpBytes {
+    fn vec_znx_big_normalize_tmp_bytes(&self, n: usize) -> usize;
+}
+
+pub trait VecZnxBigNormalize<B: Backend> {
+    fn vec_znx_big_normalize<R, A>(
+        &self,
+        basek: usize,
+        res: &mut R,
+        res_col: usize,
+        a: &A,
+        a_col: usize,
+        scratch: &mut Scratch<B>,
+    ) where
+        R: VecZnxToMut,
+        A: VecZnxBigToRef<B>;
+}
+
+pub trait VecZnxBigAutomorphism<B: Backend> {
+    /// Applies the automorphism X^i -> X^ik on `a` and stores the result on `b`.
+    fn vec_znx_big_automorphism<R, A>(&self, k: i64, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxBigToRef<B>;
+}
+
+pub trait VecZnxBigAutomorphismInplace<B: Backend> {
+    /// Applies the automorphism X^i -> X^ik on `a` and stores the result on `a`.
+    fn vec_znx_big_automorphism_inplace<A>(&self, k: i64, a: &mut A, a_col: usize)
+    where
+        A: VecZnxBigToMut<B>;
+}

poulpy-hal/src/api/vec_znx_dft.rs

@@ -0,0 +1,96 @@
+use crate::layouts::{
+    Backend, Data, Scratch, VecZnxBig, VecZnxBigToMut, VecZnxDft, VecZnxDftOwned, VecZnxDftToMut, VecZnxDftToRef, VecZnxToRef,
+};
+
+pub trait VecZnxDftAlloc<B: Backend> {
+    fn vec_znx_dft_alloc(&self, n: usize, 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>;
+}
+
+pub trait VecZnxDftAllocBytes {
+    fn vec_znx_dft_alloc_bytes(&self, n: usize, cols: usize, size: usize) -> usize;
+}
+
+pub trait VecZnxDftToVecZnxBigTmpBytes {
+    fn vec_znx_dft_to_vec_znx_big_tmp_bytes(&self, n: usize) -> usize;
+}
+
+pub trait VecZnxDftToVecZnxBig<B: Backend> {
+    fn vec_znx_dft_to_vec_znx_big<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxDftToRef<B>;
+}
+
+pub trait VecZnxDftToVecZnxBigTmpA<B: Backend> {
+    fn vec_znx_dft_to_vec_znx_big_tmp_a<R, A>(&self, res: &mut R, res_col: usize, a: &mut A, a_col: usize)
+    where
+        R: VecZnxBigToMut<B>,
+        A: VecZnxDftToMut<B>;
+}
+
+pub trait VecZnxDftToVecZnxBigConsume<B: Backend> {
+    fn vec_znx_dft_to_vec_znx_big_consume<D: Data>(&self, a: VecZnxDft<D, B>) -> VecZnxBig<D, B>
+    where
+        VecZnxDft<D, B>: VecZnxDftToMut<B>;
+}
+
+pub trait VecZnxDftAdd<B: Backend> {
+    fn vec_znx_dft_add<R, A, D>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &D, b_col: usize)
+    where
+        R: VecZnxDftToMut<B>,
+        A: VecZnxDftToRef<B>,
+        D: VecZnxDftToRef<B>;
+}
+
+pub trait VecZnxDftAddInplace<B: Backend> {
+    fn vec_znx_dft_add_inplace<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxDftToMut<B>,
+        A: VecZnxDftToRef<B>;
+}
+
+pub trait VecZnxDftSub<B: Backend> {
+    fn vec_znx_dft_sub<R, A, D>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &D, b_col: usize)
+    where
+        R: VecZnxDftToMut<B>,
+        A: VecZnxDftToRef<B>,
+        D: VecZnxDftToRef<B>;
+}
+
+pub trait VecZnxDftSubABInplace<B: Backend> {
+    fn vec_znx_dft_sub_ab_inplace<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxDftToMut<B>,
+        A: VecZnxDftToRef<B>;
+}
+
+pub trait VecZnxDftSubBAInplace<B: Backend> {
+    fn vec_znx_dft_sub_ba_inplace<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxDftToMut<B>,
+        A: VecZnxDftToRef<B>;
+}
+
+pub trait VecZnxDftCopy<B: Backend> {
+    fn vec_znx_dft_copy<R, A>(&self, step: usize, offset: usize, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxDftToMut<B>,
+        A: VecZnxDftToRef<B>;
+}
+
+pub trait VecZnxDftFromVecZnx<B: Backend> {
+    fn vec_znx_dft_from_vec_znx<R, A>(&self, step: usize, offset: usize, res: &mut R, res_col: usize, a: &A, a_col: usize)
+    where
+        R: VecZnxDftToMut<B>,
+        A: VecZnxToRef;
+}
+
+pub trait VecZnxDftZero<B: Backend> {
+    fn vec_znx_dft_zero<R>(&self, res: &mut R)
+    where
+        R: VecZnxDftToMut<B>;
+}

poulpy-hal/src/api/vmp_pmat.rs

@@ -0,0 +1,100 @@
+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>;
+}
+
+pub trait VmpPMatAllocBytes {
+    fn vmp_pmat_alloc_bytes(&self, n: usize, 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>;
+}
+
+pub trait VmpPrepareTmpBytes {
+    fn vmp_prepare_tmp_bytes(&self, n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize;
+}
+
+pub trait VmpPrepare<B: Backend> {
+    fn vmp_prepare<R, A>(&self, res: &mut R, a: &A, scratch: &mut Scratch<B>)
+    where
+        R: VmpPMatToMut<B>,
+        A: MatZnxToRef;
+}
+
+#[allow(clippy::too_many_arguments)]
+pub trait VmpApplyTmpBytes {
+    fn vmp_apply_tmp_bytes(
+        &self,
+        n: usize,
+        res_size: usize,
+        a_size: usize,
+        b_rows: usize,
+        b_cols_in: usize,
+        b_cols_out: usize,
+        b_size: usize,
+    ) -> usize;
+}
+
+pub trait VmpApply<B: Backend> {
+    /// Applies the vector matrix product [crate::layouts::VecZnxDft] x [crate::layouts::VmpPMat].
+    ///
+    /// A vector matrix product numerically equivalent to a sum of [crate::api::SvpApply],
+    /// where each [crate::layouts::SvpPPol] is a limb of the input [crate::layouts::VecZnx] in DFT,
+    /// and each vector a [crate::layouts::VecZnxDft] (row) of the [crate::layouts::VmpPMat].
+    ///
+    /// As such, given an input [crate::layouts::VecZnx] of `i` size and a [crate::layouts::VmpPMat] of `i` rows and
+    /// `j` size, the output is a [crate::layouts::VecZnx] of `j` size.
+    ///
+    /// If there is a mismatch between the dimensions the largest valid ones are used.
+    ///
+    /// ```text
+    /// |a b c d| x |e f g| = (a * |e f g| + b * |h i j| + c * |k l m|) = |n o p|
+    ///             |h i j|
+    ///             |k l m|
+    /// ```
+    /// where each element is a [crate::layouts::VecZnxDft].
+    ///
+    /// # Arguments
+    ///
+    /// * `c`: the output of the vector matrix product, as a [crate::layouts::VecZnxDft].
+    /// * `a`: the left operand [crate::layouts::VecZnxDft] of the vector matrix product.
+    /// * `b`: the right operand [crate::layouts::VmpPMat] of the vector matrix product.
+    /// * `buf`: scratch space, the size can be obtained with [VmpApplyTmpBytes::vmp_apply_tmp_bytes].
+    fn vmp_apply<R, A, C>(&self, res: &mut R, a: &A, b: &C, scratch: &mut Scratch<B>)
+    where
+        R: VecZnxDftToMut<B>,
+        A: VecZnxDftToRef<B>,
+        C: VmpPMatToRef<B>;
+}
+
+#[allow(clippy::too_many_arguments)]
+pub trait VmpApplyAddTmpBytes {
+    fn vmp_apply_add_tmp_bytes(
+        &self,
+        n: usize,
+        res_size: usize,
+        a_size: usize,
+        b_rows: usize,
+        b_cols_in: usize,
+        b_cols_out: usize,
+        b_size: usize,
+    ) -> usize;
+}
+
+pub trait VmpApplyAdd<B: Backend> {
+    fn vmp_apply_add<R, A, C>(&self, res: &mut R, a: &A, b: &C, scale: usize, scratch: &mut Scratch<B>)
+    where
+        R: VecZnxDftToMut<B>,
+        A: VecZnxDftToRef<B>,
+        C: VmpPMatToRef<B>;
+}

poulpy-hal/src/api/znx_base.rs

@@ -0,0 +1,125 @@
+use crate::{
+    layouts::{Backend, Data, DataMut, DataRef},
+    source::Source,
+};
+use rand_distr::num_traits::Zero;
+
+pub trait ZnxInfos {
+    /// Returns the ring degree of the polynomials.
+    fn n(&self) -> usize;
+
+    /// Returns the base two logarithm of the ring dimension of the polynomials.
+    fn log_n(&self) -> usize {
+        (usize::BITS - (self.n() - 1).leading_zeros()) as _
+    }
+
+    /// Returns the number of rows.
+    fn rows(&self) -> usize;
+
+    /// Returns the number of polynomials in each row.
+    fn cols(&self) -> usize;
+
+    /// Returns the number of size per polynomial.
+    fn size(&self) -> usize;
+
+    /// Returns the total number of small polynomials.
+    fn poly_count(&self) -> usize {
+        self.rows() * self.cols() * self.size()
+    }
+}
+
+pub trait ZnxSliceSizeImpl<B: Backend> {
+    fn slice_size(&self) -> usize;
+}
+
+pub trait ZnxSliceSize {
+    /// Returns the slice size, which is the offset between
+    /// two size of the same column.
+    fn sl(&self) -> usize;
+}
+
+pub trait DataView {
+    type D: Data;
+    fn data(&self) -> &Self::D;
+}
+
+pub trait DataViewMut: DataView {
+    fn data_mut(&mut self) -> &mut Self::D;
+}
+
+pub trait ZnxView: ZnxInfos + DataView<D: DataRef> {
+    type Scalar: Copy + Zero;
+
+    /// Returns a non-mutable pointer to the underlying coefficients array.
+    fn as_ptr(&self) -> *const Self::Scalar {
+        self.data().as_ref().as_ptr() as *const Self::Scalar
+    }
+
+    /// Returns a non-mutable reference to the entire underlying coefficient array.
+    fn raw(&self) -> &[Self::Scalar] {
+        unsafe { std::slice::from_raw_parts(self.as_ptr(), self.n() * self.poly_count()) }
+    }
+
+    /// Returns a non-mutable pointer starting at the j-th small polynomial of the i-th column.
+    fn at_ptr(&self, i: usize, j: usize) -> *const Self::Scalar {
+        #[cfg(debug_assertions)]
+        {
+            assert!(i < self.cols(), "cols: {} >= {}", i, self.cols());
+            assert!(j < self.size(), "size: {} >= {}", j, self.size());
+        }
+        let offset: usize = self.n() * (j * self.cols() + i);
+        unsafe { self.as_ptr().add(offset) }
+    }
+
+    /// Returns non-mutable reference to the (i, j)-th small polynomial.
+    fn at(&self, i: usize, j: usize) -> &[Self::Scalar] {
+        unsafe { std::slice::from_raw_parts(self.at_ptr(i, j), self.n()) }
+    }
+}
+
+pub trait ZnxViewMut: ZnxView + DataViewMut<D: DataMut> {
+    /// Returns a mutable pointer to the underlying coefficients array.
+    fn as_mut_ptr(&mut self) -> *mut Self::Scalar {
+        self.data_mut().as_mut().as_mut_ptr() as *mut Self::Scalar
+    }
+
+    /// Returns a mutable reference to the entire underlying coefficient array.
+    fn raw_mut(&mut self) -> &mut [Self::Scalar] {
+        unsafe { std::slice::from_raw_parts_mut(self.as_mut_ptr(), self.n() * self.poly_count()) }
+    }
+
+    /// Returns a mutable pointer starting at the j-th small polynomial of the i-th column.
+    fn at_mut_ptr(&mut self, i: usize, j: usize) -> *mut Self::Scalar {
+        #[cfg(debug_assertions)]
+        {
+            assert!(i < self.cols(), "cols: {} >= {}", i, self.cols());
+            assert!(j < self.size(), "size: {} >= {}", j, self.size());
+        }
+        let offset: usize = self.n() * (j * self.cols() + i);
+        unsafe { self.as_mut_ptr().add(offset) }
+    }
+
+    /// Returns mutable reference to the (i, j)-th small polynomial.
+    fn at_mut(&mut self, i: usize, j: usize) -> &mut [Self::Scalar] {
+        unsafe { std::slice::from_raw_parts_mut(self.at_mut_ptr(i, j), self.n()) }
+    }
+}
+
+//(Jay)Note: Can't provide blanket impl. of ZnxView because Scalar is not known
+impl<T> ZnxViewMut for T where T: ZnxView + DataViewMut<D: DataMut> {}
+
+pub trait ZnxZero
+where
+    Self: Sized,
+{
+    fn zero(&mut self);
+    fn zero_at(&mut self, i: usize, j: usize);
+}
+
+pub trait FillUniform {
+    fn fill_uniform(&mut self, source: &mut Source);
+}
+
+pub trait Reset {
+    fn reset(&mut self);
+}