Move znx layouts traits to layouts

poulpy-hal/src/layouts/encoding.rs

@@ -1,9 +1,8 @@
 use itertools::izip;
 use rug::{Assign, Float};
 
-use crate::{
-    api::{ZnxInfos, ZnxView, ZnxViewMut, ZnxZero},
-    layouts::{DataMut, DataRef, VecZnx, VecZnxToMut, VecZnxToRef, Zn, ZnToMut, ZnToRef},
+use crate::layouts::{
+    DataMut, DataRef, VecZnx, VecZnxToMut, VecZnxToRef, Zn, ZnToMut, ZnToRef, ZnxInfos, ZnxView, ZnxViewMut, ZnxZero,
 };
 
 impl<D: DataMut> VecZnx<D> {

poulpy-hal/src/layouts/mat_znx.rs

@@ -1,7 +1,9 @@
 use crate::{
     alloc_aligned,
-    api::{DataView, DataViewMut, FillUniform, Reset, ZnxInfos, ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero},
-    layouts::{Data, DataMut, DataRef, ReaderFrom, ToOwnedDeep, VecZnx, WriterTo},
+    layouts::{
+        Data, DataMut, DataRef, DataView, DataViewMut, FillUniform, ReaderFrom, Reset, ToOwnedDeep, VecZnx, WriterTo, ZnxInfos,
+        ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero,
+    },
     source::Source,
 };
 use std::fmt;

poulpy-hal/src/layouts/mod.rs

@@ -11,6 +11,7 @@ mod vec_znx_big;
 mod vec_znx_dft;
 mod vmp_pmat;
 mod zn;
+mod znx_base;
 
 pub use mat_znx::*;
 pub use module::*;
@@ -23,6 +24,7 @@ pub use vec_znx_big::*;
 pub use vec_znx_dft::*;
 pub use vmp_pmat::*;
 pub use zn::*;
+pub use znx_base::*;
 
 pub trait Data = PartialEq + Eq + Sized;
 pub trait DataRef = Data + AsRef<[u8]>;

poulpy-hal/src/layouts/scalar_znx.rs

@@ -4,8 +4,10 @@ use rand_distr::{Distribution, weighted::WeightedIndex};
 
 use crate::{
     alloc_aligned,
-    api::{DataView, DataViewMut, FillUniform, Reset, ZnxInfos, ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero},
-    layouts::{Data, DataMut, DataRef, ReaderFrom, ToOwnedDeep, VecZnx, WriterTo},
+    layouts::{
+        Data, DataMut, DataRef, DataView, DataViewMut, FillUniform, ReaderFrom, Reset, ToOwnedDeep, VecZnx, WriterTo, ZnxInfos,
+        ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero,
+    },
     source::Source,
 };
 

poulpy-hal/src/layouts/stats.rs

@@ -4,10 +4,7 @@ use rug::{
     ops::{AddAssignRound, DivAssignRound, SubAssignRound},
 };
 
-use crate::{
-    api::ZnxInfos,
-    layouts::{DataRef, VecZnx},
-};
+use crate::layouts::{DataRef, VecZnx, ZnxInfos};
 
 impl<D: DataRef> VecZnx<D> {
     pub fn std(&self, basek: usize, col: usize) -> f64 {

poulpy-hal/src/layouts/svp_ppol.rs

@@ -2,8 +2,7 @@ use std::marker::PhantomData;
 
 use crate::{
     alloc_aligned,
-    api::{DataView, DataViewMut, ZnxInfos, ZnxSliceSize, ZnxView},
-    layouts::{Backend, Data, DataMut, DataRef, ReaderFrom, WriterTo},
+    layouts::{Backend, Data, DataMut, DataRef, DataView, DataViewMut, ReaderFrom, WriterTo, ZnxInfos, ZnxSliceSize, ZnxView},
     oep::SvpPPolAllocBytesImpl,
 };
 

poulpy-hal/src/layouts/vec_znx.rs

@@ -2,8 +2,10 @@ use std::fmt;
 
 use crate::{
     alloc_aligned,
-    api::{DataView, DataViewMut, FillUniform, Reset, ZnxInfos, ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero},
-    layouts::{Data, DataMut, DataRef, ReaderFrom, ToOwnedDeep, WriterTo},
+    layouts::{
+        Data, DataMut, DataRef, DataView, DataViewMut, FillUniform, ReaderFrom, Reset, ToOwnedDeep, WriterTo, ZnxInfos,
+        ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero,
+    },
     source::Source,
 };
 

poulpy-hal/src/layouts/vec_znx_big.rs

@@ -5,8 +5,7 @@ use std::fmt;
 
 use crate::{
     alloc_aligned,
-    api::{DataView, DataViewMut, ZnxInfos, ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero},
-    layouts::{Backend, Data, DataMut, DataRef},
+    layouts::{Backend, Data, DataMut, DataRef, DataView, DataViewMut, ZnxInfos, ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero},
     oep::VecZnxBigAllocBytesImpl,
 };
 

poulpy-hal/src/layouts/vec_znx_dft.rs

@@ -4,8 +4,9 @@ use rand_distr::num_traits::Zero;
 
 use crate::{
     alloc_aligned,
-    api::{DataView, DataViewMut, ZnxInfos, ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero},
-    layouts::{Backend, Data, DataMut, DataRef, VecZnxBig},
+    layouts::{
+        Backend, Data, DataMut, DataRef, DataView, DataViewMut, VecZnxBig, ZnxInfos, ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero,
+    },
     oep::VecZnxBigAllocBytesImpl,
 };
 #[derive(PartialEq, Eq)]

poulpy-hal/src/layouts/vmp_pmat.rs

@@ -2,8 +2,7 @@ use std::marker::PhantomData;
 
 use crate::{
     alloc_aligned,
-    api::{DataView, DataViewMut, ZnxInfos, ZnxView},
-    layouts::{Backend, Data, DataMut, DataRef},
+    layouts::{Backend, Data, DataMut, DataRef, DataView, DataViewMut, ZnxInfos, ZnxView},
     oep::VmpPMatAllocBytesImpl,
 };
 

poulpy-hal/src/layouts/zn.rs

@@ -2,8 +2,10 @@ use std::fmt;
 
 use crate::{
     alloc_aligned,
-    api::{DataView, DataViewMut, FillUniform, Reset, ZnxInfos, ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero},
-    layouts::{Data, DataMut, DataRef, ReaderFrom, ToOwnedDeep, WriterTo},
+    layouts::{
+        Data, DataMut, DataRef, DataView, DataViewMut, FillUniform, ReaderFrom, Reset, ToOwnedDeep, WriterTo, ZnxInfos,
+        ZnxSliceSize, ZnxView, ZnxViewMut, ZnxZero,
+    },
     source::Source,
 };
 

poulpy-hal/src/layouts/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);
+}