wip

poulpy-hal/src/delegates/scratch.rs

@@ -1,14 +1,7 @@
 use crate::{
-    api::{
-        ScratchAvailable, ScratchFromBytes, ScratchOwnedAlloc, ScratchOwnedBorrow, TakeMatZnx, TakeScalarZnx, TakeSlice,
-        TakeSvpPPol, TakeVecZnx, TakeVecZnxBig, TakeVecZnxDft, TakeVecZnxDftSlice, TakeVecZnxSlice, TakeVmpPMat,
-    },
-    layouts::{Backend, MatZnx, ScalarZnx, Scratch, ScratchOwned, SvpPPol, VecZnx, VecZnxBig, VecZnxDft, VmpPMat},
-    oep::{
-        ScratchAvailableImpl, ScratchFromBytesImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeMatZnxImpl,
-        TakeScalarZnxImpl, TakeSliceImpl, TakeSvpPPolImpl, TakeVecZnxBigImpl, TakeVecZnxDftImpl, TakeVecZnxDftSliceImpl,
-        TakeVecZnxImpl, TakeVecZnxSliceImpl, TakeVmpPMatImpl,
-    },
+    api::{ScratchAvailable, ScratchFromBytes, ScratchOwnedAlloc, ScratchOwnedBorrow, TakeSlice},
+    layouts::{Backend, Scratch, ScratchOwned},
+    oep::{ScratchAvailableImpl, ScratchFromBytesImpl, ScratchOwnedAllocImpl, ScratchOwnedBorrowImpl, TakeSliceImpl},
 };
 
 impl<B> ScratchOwnedAlloc<B> for ScratchOwned<B>
@@ -55,104 +48,3 @@ where
         B::take_slice_impl(self, len)
     }
 }
-
-impl<B> TakeScalarZnx for Scratch<B>
-where
-    B: Backend + TakeScalarZnxImpl<B>,
-{
-    fn take_scalar_znx(&mut self, n: usize, cols: usize) -> (ScalarZnx<&mut [u8]>, &mut Self) {
-        B::take_scalar_znx_impl(self, n, cols)
-    }
-}
-
-impl<B> TakeSvpPPol<B> for Scratch<B>
-where
-    B: Backend + TakeSvpPPolImpl<B>,
-{
-    fn take_svp_ppol(&mut self, n: usize, cols: usize) -> (SvpPPol<&mut [u8], B>, &mut Self) {
-        B::take_svp_ppol_impl(self, n, cols)
-    }
-}
-
-impl<B> TakeVecZnx for Scratch<B>
-where
-    B: Backend + TakeVecZnxImpl<B>,
-{
-    fn take_vec_znx(&mut self, n: usize, cols: usize, size: usize) -> (VecZnx<&mut [u8]>, &mut Self) {
-        B::take_vec_znx_impl(self, n, cols, size)
-    }
-}
-
-impl<B> TakeVecZnxSlice for Scratch<B>
-where
-    B: Backend + TakeVecZnxSliceImpl<B>,
-{
-    fn take_vec_znx_slice(&mut self, len: usize, n: usize, cols: usize, size: usize) -> (Vec<VecZnx<&mut [u8]>>, &mut Self) {
-        B::take_vec_znx_slice_impl(self, len, n, cols, size)
-    }
-}
-
-impl<B> TakeVecZnxBig<B> for Scratch<B>
-where
-    B: Backend + TakeVecZnxBigImpl<B>,
-{
-    fn take_vec_znx_big(&mut self, n: usize, cols: usize, size: usize) -> (VecZnxBig<&mut [u8], B>, &mut Self) {
-        B::take_vec_znx_big_impl(self, n, cols, size)
-    }
-}
-
-impl<B> TakeVecZnxDft<B> for Scratch<B>
-where
-    B: Backend + TakeVecZnxDftImpl<B>,
-{
-    fn take_vec_znx_dft(&mut self, n: usize, cols: usize, size: usize) -> (VecZnxDft<&mut [u8], B>, &mut Self) {
-        B::take_vec_znx_dft_impl(self, n, cols, size)
-    }
-}
-
-impl<B> TakeVecZnxDftSlice<B> for Scratch<B>
-where
-    B: Backend + TakeVecZnxDftSliceImpl<B>,
-{
-    fn take_vec_znx_dft_slice(
-        &mut self,
-        len: usize,
-        n: usize,
-        cols: usize,
-        size: usize,
-    ) -> (Vec<VecZnxDft<&mut [u8], B>>, &mut Self) {
-        B::take_vec_znx_dft_slice_impl(self, len, n, cols, size)
-    }
-}
-
-impl<B> TakeVmpPMat<B> for Scratch<B>
-where
-    B: Backend + TakeVmpPMatImpl<B>,
-{
-    fn take_vmp_pmat(
-        &mut self,
-        n: usize,
-        rows: usize,
-        cols_in: usize,
-        cols_out: usize,
-        size: usize,
-    ) -> (VmpPMat<&mut [u8], B>, &mut Self) {
-        B::take_vmp_pmat_impl(self, n, rows, cols_in, cols_out, size)
-    }
-}
-
-impl<B> TakeMatZnx for Scratch<B>
-where
-    B: Backend + TakeMatZnxImpl<B>,
-{
-    fn take_mat_znx(
-        &mut self,
-        n: usize,
-        rows: usize,
-        cols_in: usize,
-        cols_out: usize,
-        size: usize,
-    ) -> (MatZnx<&mut [u8]>, &mut Self) {
-        B::take_mat_znx_impl(self, n, rows, cols_in, cols_out, size)
-    }
-}

poulpy-hal/src/delegates/svp_ppol.rs

@@ -1,6 +1,6 @@
 use crate::{
     api::{
-        SvpApplyDft, SvpApplyDftToDft, SvpApplyDftToDftAdd, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolAllocBytes,
+        SvpApplyDft, SvpApplyDftToDft, SvpApplyDftToDftAdd, SvpApplyDftToDftInplace, SvpPPolAlloc, SvpPPolBytesOf,
         SvpPPolFromBytes, SvpPrepare,
     },
     layouts::{
@@ -30,11 +30,11 @@ where
     }
 }
 
-impl<B> SvpPPolAllocBytes for Module<B>
+impl<B> SvpPPolBytesOf for Module<B>
 where
     B: Backend + SvpPPolAllocBytesImpl<B>,
 {
-    fn svp_ppol_bytes_of(&self, cols: usize) -> usize {
+    fn bytes_of_svp_ppol(&self, cols: usize) -> usize {
         B::svp_ppol_bytes_of_impl(self.n(), cols)
     }
 }

poulpy-hal/src/delegates/vec_znx_big.rs

@@ -1,7 +1,7 @@
 use crate::{
     api::{
         VecZnxBigAdd, VecZnxBigAddInplace, VecZnxBigAddNormal, VecZnxBigAddSmall, VecZnxBigAddSmallInplace, VecZnxBigAlloc,
-        VecZnxBigAllocBytes, VecZnxBigAutomorphism, VecZnxBigAutomorphismInplace, VecZnxBigAutomorphismInplaceTmpBytes,
+        VecZnxBigAutomorphism, VecZnxBigAutomorphismInplace, VecZnxBigAutomorphismInplaceTmpBytes, VecZnxBigBytesOf,
         VecZnxBigFromBytes, VecZnxBigFromSmall, VecZnxBigNegate, VecZnxBigNegateInplace, VecZnxBigNormalize,
         VecZnxBigNormalizeTmpBytes, VecZnxBigSub, VecZnxBigSubInplace, VecZnxBigSubNegateInplace, VecZnxBigSubSmallA,
         VecZnxBigSubSmallB, VecZnxBigSubSmallInplace, VecZnxBigSubSmallNegateInplace,
@@ -49,11 +49,11 @@ where
     }
 }
 
-impl<B> VecZnxBigAllocBytes for Module<B>
+impl<B> VecZnxBigBytesOf for Module<B>
 where
     B: Backend + VecZnxBigAllocBytesImpl<B>,
 {
-    fn vec_znx_big_bytes_of(&self, cols: usize, size: usize) -> usize {
+    fn bytes_of_vec_znx_big(&self, cols: usize, size: usize) -> usize {
         B::vec_znx_big_bytes_of_impl(self.n(), cols, size)
     }
 }

poulpy-hal/src/delegates/vec_znx_dft.rs

@@ -1,8 +1,8 @@
 use crate::{
     api::{
-        VecZnxDftAdd, VecZnxDftAddInplace, VecZnxDftAlloc, VecZnxDftAllocBytes, VecZnxDftApply, VecZnxDftCopy,
-        VecZnxDftFromBytes, VecZnxDftSub, VecZnxDftSubInplace, VecZnxDftSubNegateInplace, VecZnxDftZero, VecZnxIdftApply,
-        VecZnxIdftApplyConsume, VecZnxIdftApplyTmpA, VecZnxIdftApplyTmpBytes,
+        VecZnxDftAdd, VecZnxDftAddInplace, VecZnxDftAlloc, VecZnxDftApply, VecZnxDftBytesOf, VecZnxDftCopy, VecZnxDftFromBytes,
+        VecZnxDftSub, VecZnxDftSubInplace, VecZnxDftSubNegateInplace, VecZnxDftZero, VecZnxIdftApply, VecZnxIdftApplyConsume,
+        VecZnxIdftApplyTmpA, VecZnxIdftApplyTmpBytes,
     },
     layouts::{
         Backend, Data, Module, Scratch, VecZnxBig, VecZnxBigToMut, VecZnxDft, VecZnxDftOwned, VecZnxDftToMut, VecZnxDftToRef,
@@ -24,11 +24,11 @@ where
     }
 }
 
-impl<B> VecZnxDftAllocBytes for Module<B>
+impl<B> VecZnxDftBytesOf for Module<B>
 where
     B: Backend + VecZnxDftAllocBytesImpl<B>,
 {
-    fn vec_znx_dft_bytes_of(&self, cols: usize, size: usize) -> usize {
+    fn bytes_of_vec_znx_dft(&self, cols: usize, size: usize) -> usize {
         B::vec_znx_dft_bytes_of_impl(self.n(), cols, size)
     }
 }

poulpy-hal/src/delegates/vmp_pmat.rs

@@ -1,7 +1,7 @@
 use crate::{
     api::{
         VmpApplyDft, VmpApplyDftTmpBytes, VmpApplyDftToDft, VmpApplyDftToDftAdd, VmpApplyDftToDftAddTmpBytes,
-        VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPMatAllocBytes, VmpPMatFromBytes, VmpPrepare, VmpPrepareTmpBytes,
+        VmpApplyDftToDftTmpBytes, VmpPMatAlloc, VmpPMatBytesOf, VmpPMatFromBytes, VmpPrepare, VmpPrepareTmpBytes,
     },
     layouts::{
         Backend, MatZnxToRef, Module, Scratch, VecZnxDftToMut, VecZnxDftToRef, VecZnxToRef, VmpPMatOwned, VmpPMatToMut,
@@ -23,11 +23,11 @@ where
     }
 }
 
-impl<B> VmpPMatAllocBytes for Module<B>
+impl<B> VmpPMatBytesOf for Module<B>
 where
     B: Backend + VmpPMatAllocBytesImpl<B>,
 {
-    fn vmp_pmat_bytes_of(&self, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize {
+    fn bytes_of_vmp_pmat(&self, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize {
         B::vmp_pmat_bytes_of_impl(self.n(), rows, cols_in, cols_out, size)
     }
 }