Trait ScratchArenaTakeBasic 

pub trait ScratchArenaTakeBasic<'a, B: Backend>: Sized {
    // 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".

Implementors

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