Trait ScratchArenaTakeBasic 

pub trait ScratchArenaTakeBasic<'a, B>: Sized
where
    B: Backend,
{
    // Required methods
    fn take_cnv_pvec_left_scratch<M>(
        self,
        module: &M,
        cols: usize,
        size: usize,
    ) -> (CnvPVecLViewMut<'a, B>, Self)
       where B: 'a,
             M: ModuleN + CnvPVecBytesOf;
    fn take_cnv_pvec_right_scratch<M>(
        self,
        module: &M,
        cols: usize,
        size: usize,
    ) -> (CnvPVecRViewMut<'a, B>, Self)
       where B: 'a,
             M: ModuleN + CnvPVecBytesOf;
    fn take_scalar_znx_scratch(
        self,
        n: usize,
        cols: usize,
    ) -> (ScalarZnxViewMut<'a, B>, Self)
       where B: 'a;
    fn take_svp_ppol_scratch<M>(
        self,
        module: &M,
        cols: usize,
    ) -> (SvpPPolViewMut<'a, B>, Self)
       where B: 'a,
             M: SvpPPolBytesOf + ModuleN;
    fn take_vec_znx_scratch(
        self,
        n: usize,
        cols: usize,
        size: usize,
    ) -> (VecZnxViewMut<'a, B>, Self)
       where B: 'a;
    fn take_vec_znx_big_scratch<M>(
        self,
        module: &M,
        cols: usize,
        size: usize,
    ) -> (VecZnxBigViewMut<'a, B>, Self)
       where B: 'a,
             M: VecZnxBigBytesOf + ModuleN;
    fn take_vec_znx_big_scratch_n(
        self,
        n: usize,
        cols: usize,
        size: usize,
    ) -> (VecZnxBigViewMut<'a, B>, Self)
       where B: 'a;
    fn take_vec_znx_dft_scratch<M>(
        self,
        module: &M,
        cols: usize,
        size: usize,
    ) -> (VecZnxDftViewMut<'a, B>, Self)
       where B: 'a,
             M: VecZnxDftBytesOf + ModuleN;
    fn take_vmp_pmat_scratch<M>(
        self,
        module: &M,
        rows: usize,
        cols_in: usize,
        cols_out: usize,
        size: usize,
    ) -> (VmpPMatViewMut<'a, B>, Self)
       where B: 'a,
             M: VmpPMatBytesOf + ModuleN;
    fn take_mat_znx_scratch(
        self,
        n: usize,
        rows: usize,
        cols_in: usize,
        cols_out: usize,
        size: usize,
    ) -> (MatZnxViewMut<'a, B>, Self)
       where B: 'a;

    // Provided methods
    fn take_vec_znx_dft_slice_scratch<M>(
        self,
        module: &M,
        len: usize,
        cols: usize,
        size: usize,
    ) -> (Vec<VecZnxDftViewMut<'a, B>>, Self)
       where B: 'a,
             M: VecZnxDftBytesOf + ModuleN { ... }
    fn take_vec_znx_slice_scratch(
        self,
        len: usize,
        n: usize,
        cols: usize,
        size: usize,
    ) -> (Vec<VecZnxViewMut<'a, B>>, Self)
       where B: 'a { ... }
}

Backend-native arena allocation of typed HAL layouts.

This is the additive, backend-owned scratch path introduced for incremental device-backend integration. It consumes a ScratchArena by value and returns the carved layout together with the remaining arena.

Required Methods

fn take_cnv_pvec_left_scratch<M>( self, module: &M, cols: usize, size: usize, ) -> (CnvPVecLViewMut<'a, B>, Self)

where B: 'a, M: ModuleN + CnvPVecBytesOf,

Takes a CnvPVecL from the scratch arena.

fn take_cnv_pvec_right_scratch<M>( self, module: &M, cols: usize, size: usize, ) -> (CnvPVecRViewMut<'a, B>, Self)

where B: 'a, M: ModuleN + CnvPVecBytesOf,

Takes a CnvPVecR from the scratch arena.

fn take_scalar_znx_scratch( self, n: usize, cols: usize, ) -> (ScalarZnxViewMut<'a, B>, Self)

where B: 'a,

Takes a ScalarZnx from the scratch arena.

fn take_svp_ppol_scratch<M>( self, module: &M, cols: usize, ) -> (SvpPPolViewMut<'a, B>, Self)

where B: 'a, M: SvpPPolBytesOf + ModuleN,

Takes a SvpPPol from the scratch arena.

fn take_vec_znx_scratch( self, n: usize, cols: usize, size: usize, ) -> (VecZnxViewMut<'a, B>, Self)

where B: 'a,

Takes a VecZnx from the scratch arena.

fn take_vec_znx_big_scratch<M>( self, module: &M, cols: usize, size: usize, ) -> (VecZnxBigViewMut<'a, B>, Self)

where B: 'a, M: VecZnxBigBytesOf + ModuleN,

Takes a VecZnxBig from the scratch arena.

fn take_vec_znx_big_scratch_n( self, n: usize, cols: usize, size: usize, ) -> (VecZnxBigViewMut<'a, B>, Self)

where B: 'a,

fn take_vec_znx_dft_scratch<M>( self, module: &M, cols: usize, size: usize, ) -> (VecZnxDftViewMut<'a, B>, Self)

where B: 'a, M: VecZnxDftBytesOf + ModuleN,

Takes a VecZnxDft from the scratch arena.

fn take_vmp_pmat_scratch<M>( self, module: &M, rows: usize, cols_in: usize, cols_out: usize, size: usize, ) -> (VmpPMatViewMut<'a, B>, Self)

where B: 'a, M: VmpPMatBytesOf + ModuleN,

Takes a VmpPMat from the scratch arena.

fn take_mat_znx_scratch( self, n: usize, rows: usize, cols_in: usize, cols_out: usize, size: usize, ) -> (MatZnxViewMut<'a, B>, Self)

where B: 'a,

Takes a MatZnx from the scratch arena.

Provided Methods

fn take_vec_znx_dft_slice_scratch<M>( self, module: &M, len: usize, cols: usize, size: usize, ) -> (Vec<VecZnxDftViewMut<'a, B>>, Self)

where B: 'a, M: VecZnxDftBytesOf + ModuleN,

Takes len consecutive VecZnxDft objects from the scratch arena.

fn take_vec_znx_slice_scratch( self, len: usize, n: usize, cols: usize, size: usize, ) -> (Vec<VecZnxViewMut<'a, B>>, Self)

where B: 'a,

Takes len consecutive VecZnx objects from the scratch arena.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a, B> ScratchArenaTakeBasic<'a, B> for ScratchArena<'a, B>

where B: Backend,