Struct Module 

pub struct Module<B: Backend> { /* private fields */ }

Implementations

impl<B: Backend> Module<B>

pub fn new_marker(n: u64) -> Self

pub unsafe fn from_nonnull(ptr: NonNull<B::Handle>, n: u64) -> Self

pub unsafe fn from_raw_parts(ptr: *mut B::Handle, n: u64) -> Self

Construct from a raw pointer managed elsewhere. SAFETY: ptr must be non-null and remain valid for the lifetime of this Module.

pub unsafe fn ptr(&self) -> *mut <B as Backend>::Handle

pub fn n(&self) -> usize

pub fn as_mut_ptr(&self) -> *mut B::Handle

pub fn log_n(&self) -> usize

Trait Implementations

impl<BE: Backend> Convolution<BE> for Module<BE>

where Self: Sized + ModuleN + SvpPPolAlloc<BE> + SvpApplyDftToDft<BE> + SvpPrepare<BE> + SvpPPolBytesOf + VecZnxDftBytesOf + VecZnxDftAddScaledInplace<BE>, Scratch<BE>: ScratchTakeBasic,

fn convolution_tmp_bytes(&self, res_size: usize) -> usize

fn convolution<R, A, B>( &self, res: &mut R, res_scale: i64, a: &A, b: &B, scratch: &mut Scratch<BE>, )

where R: VecZnxDftToMut<BE>, A: VecZnxToRef, B: VecZnxDftToRef<BE>,

Evaluates a bivariate convolution over Z[X, Y] / (X^N + 1) where Y = 2^-K and scales the result by 2^{res_scale * K}

impl<BE: Backend> CyclotomicOrder for Module<BE>

where Self: ModuleN,

fn cyclotomic_order(&self) -> i64

impl<B: Backend> Drop for Module<B>

fn drop(&mut self)

Executes the destructor for this type.

impl<BE: Backend> GaloisElement for Module<BE>

where Self: CyclotomicOrder,

fn galois_element(&self, generator: i64) -> i64

fn galois_element_inv(&self, gal_el: i64) -> i64

impl<BE: Backend> ModuleLogN for Module<BE>

where Self: ModuleN,

fn log_n(&self) -> usize

impl<B> ModuleN for Module<B>

where B: Backend,

fn n(&self) -> usize

impl<B> ModuleNew<B> for Module<B>

where B: Backend + ModuleNewImpl<B>,

fn new(n: u64) -> Self

impl<B> SvpApplyDft<B> for Module<B>

where B: Backend + SvpApplyDftImpl<B>,

fn svp_apply_dft<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: VecZnxToRef,

impl<B> SvpApplyDftToDft<B> for Module<B>

where B: Backend + SvpApplyDftToDftImpl<B>,

fn svp_apply_dft_to_dft<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>,

impl<B> SvpApplyDftToDftAdd<B> for Module<B>

where B: Backend + SvpApplyDftToDftAddImpl<B>,

fn svp_apply_dft_to_dft_add<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>,

impl<B> SvpApplyDftToDftInplace<B> for Module<B>

where B: Backend + SvpApplyDftToDftInplaceImpl,

fn svp_apply_dft_to_dft_inplace<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxDftToMut<B>, A: SvpPPolToRef<B>,

impl<B> SvpPPolAlloc<B> for Module<B>

where B: Backend + SvpPPolAllocImpl<B>,

fn svp_ppol_alloc(&self, cols: usize) -> SvpPPolOwned<B>

impl<B> SvpPPolBytesOf for Module<B>

where B: Backend + SvpPPolAllocBytesImpl<B>,

fn bytes_of_svp_ppol(&self, cols: usize) -> usize

impl<B> SvpPPolFromBytes<B> for Module<B>

where B: Backend + SvpPPolFromBytesImpl<B>,

fn svp_ppol_from_bytes(&self, cols: usize, bytes: Vec<u8>) -> SvpPPolOwned<B>

impl<B> SvpPrepare<B> for Module<B>

where B: Backend + SvpPrepareImpl<B>,

fn svp_prepare<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)

where R: SvpPPolToMut<B>, A: ScalarZnxToRef,

impl<B> VecZnxAdd for Module<B>

where B: Backend + VecZnxAddImpl<B>,

fn vec_znx_add<R, A, C>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize, )

where R: VecZnxToMut, A: VecZnxToRef, C: VecZnxToRef,

Adds the selected column of a to the selected column of b and writes the result on the selected column of res.

impl<B> VecZnxAddInplace for Module<B>

where B: Backend + VecZnxAddInplaceImpl<B>,

fn vec_znx_add_inplace<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxToMut, A: VecZnxToRef,

Adds the selected column of a to the selected column of res and writes the result on the selected column of res.

impl<B> VecZnxAddNormal for Module<B>

where B: Backend + VecZnxAddNormalImpl<B>,

fn vec_znx_add_normal<R>( &self, base2k: usize, res: &mut R, res_col: usize, k: usize, source: &mut Source, sigma: f64, bound: f64, )

where R: VecZnxToMut,

Adds a discrete normal vector scaled by 2^{-k} with the provided standard deviation and bounded to [-bound, bound].

impl<B> VecZnxAddScalar for Module<B>

where B: Backend + VecZnxAddScalarImpl<B>,

fn vec_znx_add_scalar<R, A, D>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &D, b_col: usize, b_limb: usize, )

where R: VecZnxToMut, A: ScalarZnxToRef, D: VecZnxToRef,

Adds the selected column of a on the selected column and limb of b and writes the result on the selected column of res.

impl<B> VecZnxAddScalarInplace for Module<B>

where B: Backend + VecZnxAddScalarInplaceImpl<B>,

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,

Adds the selected column of a on the selected column and limb of res.

impl<B> VecZnxAutomorphism for Module<B>

where B: Backend + VecZnxAutomorphismImpl<B>,

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,

Applies the automorphism X^i -> X^ik on the selected column of a and stores the result in res_col column of res.

impl<B> VecZnxAutomorphismInplace<B> for Module<B>

where B: Backend + VecZnxAutomorphismInplaceImpl<B>,

fn vec_znx_automorphism_inplace<R>( &self, k: i64, res: &mut R, res_col: usize, scratch: &mut Scratch<B>, )

where R: VecZnxToMut,

Applies the automorphism X^i -> X^ik on the selected column of a.

impl<B> VecZnxAutomorphismInplaceTmpBytes for Module<B>

where B: Backend + VecZnxAutomorphismInplaceTmpBytesImpl<B>,

fn vec_znx_automorphism_inplace_tmp_bytes(&self) -> usize

impl<B> VecZnxBigAdd<B> for Module<B>

where B: Backend + VecZnxBigAddImpl<B>,

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>,

Adds a to b and stores the result on c.

impl<B> VecZnxBigAddInplace<B> for Module<B>

where B: Backend + VecZnxBigAddInplaceImpl<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>,

Adds a to b and stores the result on b.

impl<B> VecZnxBigAddNormal<B> for Module<B>

where B: Backend + VecZnxBigAddNormalImpl<B>,

fn vec_znx_big_add_normal<R: VecZnxBigToMut<B>>( &self, base2k: usize, res: &mut R, res_col: usize, k: usize, source: &mut Source, sigma: f64, bound: f64, )

impl<B> VecZnxBigAddSmall<B> for Module<B>

where B: Backend + VecZnxBigAddSmallImpl<B>,

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,

Adds a to b and stores the result on c.

impl<B> VecZnxBigAddSmallInplace<B> for Module<B>

where B: Backend + VecZnxBigAddSmallInplaceImpl<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,

Adds a to b and stores the result on b.

impl<B> VecZnxBigAlloc<B> for Module<B>

where B: Backend + VecZnxBigAllocImpl<B>,

fn vec_znx_big_alloc(&self, cols: usize, size: usize) -> VecZnxBigOwned<B>

impl<B> VecZnxBigAutomorphism<B> for Module<B>

where B: Backend + VecZnxBigAutomorphismImpl<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>,

Applies the automorphism X^i -> X^ik on a and stores the result on b.

impl<B> VecZnxBigAutomorphismInplace<B> for Module<B>

where B: Backend + VecZnxBigAutomorphismInplaceImpl<B>,

fn vec_znx_big_automorphism_inplace<A>( &self, k: i64, a: &mut A, a_col: usize, scratch: &mut Scratch<B>, )

where A: VecZnxBigToMut<B>,

Applies the automorphism X^i -> X^ik on a and stores the result on a.

impl<B> VecZnxBigAutomorphismInplaceTmpBytes for Module<B>

where B: Backend + VecZnxBigAutomorphismInplaceTmpBytesImpl<B>,

fn vec_znx_big_automorphism_inplace_tmp_bytes(&self) -> usize

impl<B> VecZnxBigBytesOf for Module<B>

where B: Backend + VecZnxBigAllocBytesImpl<B>,

fn bytes_of_vec_znx_big(&self, cols: usize, size: usize) -> usize

impl<B> VecZnxBigFromBytes<B> for Module<B>

where B: Backend + VecZnxBigFromBytesImpl<B>,

fn vec_znx_big_from_bytes( &self, cols: usize, size: usize, bytes: Vec<u8>, ) -> VecZnxBigOwned<B>

impl<B> VecZnxBigFromSmall<B> for Module<B>

where B: Backend + VecZnxBigFromSmallImpl<B>,

fn vec_znx_big_from_small<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxBigToMut<B>, A: VecZnxToRef,

impl<B> VecZnxBigNegate<B> for Module<B>

where B: Backend + VecZnxBigNegateImpl<B>,

fn vec_znx_big_negate<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxBigToMut<B>, A: VecZnxBigToRef<B>,

impl<B> VecZnxBigNegateInplace<B> for Module<B>

where B: Backend + VecZnxBigNegateInplaceImpl<B>,

fn vec_znx_big_negate_inplace<A>(&self, a: &mut A, a_col: usize)

where A: VecZnxBigToMut<B>,

impl<B> VecZnxBigNormalize<B> for Module<B>

where B: Backend + VecZnxBigNormalizeImpl<B>,

fn vec_znx_big_normalize<R, A>( &self, res_basek: usize, res: &mut R, res_col: usize, a_basek: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>, )

where R: VecZnxToMut, A: VecZnxBigToRef<B>,

impl<B> VecZnxBigNormalizeTmpBytes for Module<B>

where B: Backend + VecZnxBigNormalizeTmpBytesImpl<B>,

fn vec_znx_big_normalize_tmp_bytes(&self) -> usize

impl<B> VecZnxBigSub<B> for Module<B>

where B: Backend + VecZnxBigSubImpl<B>,

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>,

Subtracts a to b and stores the result on c.

impl<B> VecZnxBigSubInplace<B> for Module<B>

where B: Backend + VecZnxBigSubInplaceImpl<B>,

fn vec_znx_big_sub_inplace<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxBigToMut<B>, A: VecZnxBigToRef<B>,

Subtracts a from b and stores the result on b.

impl<B> VecZnxBigSubNegateInplace<B> for Module<B>

where B: Backend + VecZnxBigSubNegateInplaceImpl<B>,

fn vec_znx_big_sub_negate_inplace<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxBigToMut<B>, A: VecZnxBigToRef<B>,

Subtracts b from a and stores the result on b.

impl<B> VecZnxBigSubSmallA<B> for Module<B>

where B: Backend + VecZnxBigSubSmallAImpl<B>,

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>,

Subtracts b from a and stores the result on c.

impl<B> VecZnxBigSubSmallB<B> for Module<B>

where B: Backend + VecZnxBigSubSmallBImpl<B>,

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,

Subtracts b from a and stores the result on c.

impl<B> VecZnxBigSubSmallInplace<B> for Module<B>

where B: Backend + VecZnxBigSubSmallInplaceImpl<B>,

fn vec_znx_big_sub_small_inplace<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxBigToMut<B>, A: VecZnxToRef,

Subtracts a from res and stores the result on res.

impl<B> VecZnxBigSubSmallNegateInplace<B> for Module<B>

where B: Backend + VecZnxBigSubSmallNegateInplaceImpl<B>,

fn vec_znx_big_sub_small_negate_inplace<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxBigToMut<B>, A: VecZnxToRef,

Subtracts res from a and stores the result on res.

impl<B> VecZnxCopy for Module<B>

where B: Backend + VecZnxCopyImpl<B>,

fn vec_znx_copy<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)

where R: VecZnxToMut, A: VecZnxToRef,

impl<B> VecZnxDftAdd<B> for Module<B>

where B: Backend + VecZnxDftAddImpl<B>,

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>,

impl<B> VecZnxDftAddInplace<B> for Module<B>

where B: Backend + VecZnxDftAddInplaceImpl<B>,

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>,

impl<B> VecZnxDftAddScaledInplace<B> for Module<B>

where B: Backend + VecZnxDftAddScaledInplaceImpl<B>,

fn vec_znx_dft_add_scaled_inplace<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, a_scale: i64, )

where R: VecZnxDftToMut<B>, A: VecZnxDftToRef<B>,

impl<B> VecZnxDftAlloc<B> for Module<B>

where B: Backend + VecZnxDftAllocImpl<B>,

fn vec_znx_dft_alloc(&self, cols: usize, size: usize) -> VecZnxDftOwned<B>

impl<B> VecZnxDftApply<B> for Module<B>

where B: Backend + VecZnxDftApplyImpl<B>,

fn vec_znx_dft_apply<R, A>( &self, step: usize, offset: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxDftToMut<B>, A: VecZnxToRef,

impl<B> VecZnxDftBytesOf for Module<B>

where B: Backend + VecZnxDftAllocBytesImpl<B>,

fn bytes_of_vec_znx_dft(&self, cols: usize, size: usize) -> usize

impl<B> VecZnxDftCopy<B> for Module<B>

where B: Backend + VecZnxDftCopyImpl<B>,

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>,

impl<B> VecZnxDftFromBytes<B> for Module<B>

where B: Backend + VecZnxDftFromBytesImpl<B>,

fn vec_znx_dft_from_bytes( &self, cols: usize, size: usize, bytes: Vec<u8>, ) -> VecZnxDftOwned<B>

impl<B> VecZnxDftSub<B> for Module<B>

where B: Backend + VecZnxDftSubImpl<B>,

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>,

impl<B> VecZnxDftSubInplace<B> for Module<B>

where B: Backend + VecZnxDftSubInplaceImpl<B>,

fn vec_znx_dft_sub_inplace<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxDftToMut<B>, A: VecZnxDftToRef<B>,

impl<B> VecZnxDftSubNegateInplace<B> for Module<B>

where B: Backend + VecZnxDftSubNegateInplaceImpl<B>,

fn vec_znx_dft_sub_negate_inplace<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxDftToMut<B>, A: VecZnxDftToRef<B>,

impl<B> VecZnxDftZero<B> for Module<B>

where B: Backend + VecZnxDftZeroImpl<B>,

fn vec_znx_dft_zero<R>(&self, res: &mut R)

where R: VecZnxDftToMut<B>,

impl<B> VecZnxFillNormal for Module<B>

where B: Backend + VecZnxFillNormalImpl<B>,

fn vec_znx_fill_normal<R>( &self, base2k: usize, res: &mut R, res_col: usize, k: usize, source: &mut Source, sigma: f64, bound: f64, )

where R: VecZnxToMut,

impl<B> VecZnxFillUniform for Module<B>

where B: Backend + VecZnxFillUniformImpl<B>,

fn vec_znx_fill_uniform<R>( &self, base2k: usize, res: &mut R, res_col: usize, source: &mut Source, )

where R: VecZnxToMut,

Fills the first size size with uniform values in [-2^{base2k-1}, 2^{base2k-1}]

impl<B> VecZnxIdftApply<B> for Module<B>

where B: Backend + VecZnxIdftApplyImpl<B>,

fn vec_znx_idft_apply<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>,

impl<B> VecZnxIdftApplyConsume<B> for Module<B>

where B: Backend + VecZnxIdftApplyConsumeImpl<B>,

fn vec_znx_idft_apply_consume<D: Data>( &self, a: VecZnxDft<D, B>, ) -> VecZnxBig<D, B>

where VecZnxDft<D, B>: VecZnxDftToMut<B>,

impl<B> VecZnxIdftApplyTmpA<B> for Module<B>

where B: Backend + VecZnxIdftApplyTmpAImpl<B>,

fn vec_znx_idft_apply_tmpa<R, A>( &self, res: &mut R, res_col: usize, a: &mut A, a_col: usize, )

where R: VecZnxBigToMut<B>, A: VecZnxDftToMut<B>,

impl<B> VecZnxIdftApplyTmpBytes for Module<B>

where B: Backend + VecZnxIdftApplyTmpBytesImpl<B>,

fn vec_znx_idft_apply_tmp_bytes(&self) -> usize

impl<B> VecZnxLsh<B> for Module<B>

where B: Backend + VecZnxLshImpl<B>,

fn vec_znx_lsh<R, A>( &self, base2k: usize, k: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>, )

where R: VecZnxToMut, A: VecZnxToRef,

Left shift by k bits all columns of a.

impl<B> VecZnxLshInplace<B> for Module<B>

where B: Backend + VecZnxLshInplaceImpl<B>,

fn vec_znx_lsh_inplace<A>( &self, base2k: usize, k: usize, a: &mut A, a_col: usize, scratch: &mut Scratch<B>, )

where A: VecZnxToMut,

Left shift by k bits all columns of a.

impl<B> VecZnxLshTmpBytes for Module<B>

where B: Backend + VecZnxLshTmpBytesImpl<B>,

fn vec_znx_lsh_tmp_bytes(&self) -> usize

impl<B> VecZnxMergeRings<B> for Module<B>

where B: Backend + VecZnxMergeRingsImpl<B>,

fn vec_znx_merge_rings<R, A>( &self, res: &mut R, res_col: usize, a: &[A], a_col: usize, scratch: &mut Scratch<B>, )

where R: VecZnxToMut, A: VecZnxToRef,

Merges the subrings of the selected column of a into the selected column of res.

impl<B> VecZnxMergeRingsTmpBytes for Module<B>

where B: Backend + VecZnxMergeRingsTmpBytesImpl<B>,

fn vec_znx_merge_rings_tmp_bytes(&self) -> usize

impl<B> VecZnxMulXpMinusOne for Module<B>

where B: Backend + VecZnxMulXpMinusOneImpl<B>,

fn vec_znx_mul_xp_minus_one<R, A>( &self, p: i64, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxToMut, A: VecZnxToRef,

impl<B> VecZnxMulXpMinusOneInplace<B> for Module<B>

where B: Backend + VecZnxMulXpMinusOneInplaceImpl<B>,

fn vec_znx_mul_xp_minus_one_inplace<R>( &self, p: i64, res: &mut R, res_col: usize, scratch: &mut Scratch<B>, )

where R: VecZnxToMut,

impl<B> VecZnxMulXpMinusOneInplaceTmpBytes for Module<B>

where B: Backend + VecZnxMulXpMinusOneInplaceTmpBytesImpl<B>,

fn vec_znx_mul_xp_minus_one_inplace_tmp_bytes(&self) -> usize

impl<B> VecZnxNegate for Module<B>

where B: Backend + VecZnxNegateImpl<B>,

fn vec_znx_negate<R, A>(&self, res: &mut R, res_col: usize, a: &A, a_col: usize)

where R: VecZnxToMut, A: VecZnxToRef,

impl<B> VecZnxNegateInplace for Module<B>

where B: Backend + VecZnxNegateInplaceImpl<B>,

fn vec_znx_negate_inplace<A>(&self, a: &mut A, a_col: usize)

where A: VecZnxToMut,

Negates the selected column of a.

impl<B> VecZnxNormalize<B> for Module<B>

where B: Backend + VecZnxNormalizeImpl<B>,

fn vec_znx_normalize<R, A>( &self, res_basek: usize, res: &mut R, res_col: usize, a_basek: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>, )

where R: VecZnxToMut, A: VecZnxToRef,

Normalizes the selected column of a and stores the result into the selected column of res.

impl<B> VecZnxNormalizeInplace<B> for Module<B>

where B: Backend + VecZnxNormalizeInplaceImpl<B>,

fn vec_znx_normalize_inplace<A>( &self, base2k: usize, a: &mut A, a_col: usize, scratch: &mut Scratch<B>, )

where A: VecZnxToMut,

Normalizes the selected column of a.

impl<B> VecZnxNormalizeTmpBytes for Module<B>

where B: Backend + VecZnxNormalizeTmpBytesImpl<B>,

fn vec_znx_normalize_tmp_bytes(&self) -> usize

Returns the minimum number of bytes necessary for normalization.

impl<B> VecZnxRotate for Module<B>

where B: Backend + VecZnxRotateImpl<B>,

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,

Multiplies the selected column of a by X^k and stores the result in res_col of res.

impl<B> VecZnxRotateInplace<B> for Module<B>

where B: Backend + VecZnxRotateInplaceImpl<B>,

fn vec_znx_rotate_inplace<A>( &self, k: i64, a: &mut A, a_col: usize, scratch: &mut Scratch<B>, )

where A: VecZnxToMut,

Multiplies the selected column of a by X^k.

impl<B> VecZnxRotateInplaceTmpBytes for Module<B>

where B: Backend + VecZnxRotateInplaceTmpBytesImpl<B>,

fn vec_znx_rotate_inplace_tmp_bytes(&self) -> usize

impl<B> VecZnxRsh<B> for Module<B>

where B: Backend + VecZnxRshImpl<B>,

fn vec_znx_rsh<R, A>( &self, base2k: usize, k: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>, )

where R: VecZnxToMut, A: VecZnxToRef,

Right shift by k bits all columns of a.

impl<B> VecZnxRshInplace<B> for Module<B>

where B: Backend + VecZnxRshInplaceImpl<B>,

fn vec_znx_rsh_inplace<A>( &self, base2k: usize, k: usize, a: &mut A, a_col: usize, scratch: &mut Scratch<B>, )

where A: VecZnxToMut,

Right shift by k bits all columns of a.

impl<B> VecZnxRshTmpBytes for Module<B>

where B: Backend + VecZnxRshTmpBytesImpl<B>,

fn vec_znx_rsh_tmp_bytes(&self) -> usize

impl<B> VecZnxSplitRing<B> for Module<B>

where B: Backend + VecZnxSplitRingImpl<B>,

fn vec_znx_split_ring<R, A>( &self, res: &mut [R], res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch<B>, )

where R: VecZnxToMut, A: VecZnxToRef,

Splits the selected columns of b into subrings and copies them them into the selected column of res.

impl<B> VecZnxSplitRingTmpBytes for Module<B>

where B: Backend + VecZnxSplitRingTmpBytesImpl<B>,

fn vec_znx_split_ring_tmp_bytes(&self) -> usize

impl<B> VecZnxSub for Module<B>

where B: Backend + VecZnxSubImpl<B>,

fn vec_znx_sub<R, A, C>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &C, b_col: usize, )

where R: VecZnxToMut, A: VecZnxToRef, C: VecZnxToRef,

Subtracts the selected column of b from the selected column of a and writes the result on the selected column of res.

impl<B> VecZnxSubInplace for Module<B>

where B: Backend + VecZnxSubInplaceImpl<B>,

fn vec_znx_sub_inplace<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxToMut, A: VecZnxToRef,

Subtracts the selected column of a from the selected column of res inplace.

impl<B> VecZnxSubNegateInplace for Module<B>

where B: Backend + VecZnxSubNegateInplaceImpl<B>,

fn vec_znx_sub_negate_inplace<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxToMut, A: VecZnxToRef,

Subtracts the selected column of res from the selected column of a and inplace mutates res

impl<B> VecZnxSubScalar for Module<B>

where B: Backend + VecZnxSubScalarImpl<B>,

fn vec_znx_sub_scalar<R, A, D>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &D, b_col: usize, b_limb: usize, )

where R: VecZnxToMut, A: ScalarZnxToRef, D: VecZnxToRef,

Subtracts the selected column of a on the selected column and limb of b and writes the result on the selected column of res.

impl<B> VecZnxSubScalarInplace for Module<B>

where B: Backend + VecZnxSubScalarInplaceImpl<B>,

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,

Subtracts the selected column of a on the selected column and limb of res.

impl<B> VecZnxSwitchRing for Module<B>

where B: Backend + VecZnxSwitchRingImpl<B>,

fn vec_znx_switch_ring<R, A>( &self, res: &mut R, res_col: usize, a: &A, a_col: usize, )

where R: VecZnxToMut, A: VecZnxToRef,

impl<B> VmpApplyDft<B> for Module<B>

where B: Backend + VmpApplyDftImpl<B>,

fn vmp_apply_dft<R, A, C>( &self, res: &mut R, a: &A, b: &C, scratch: &mut Scratch<B>, )

where R: VecZnxDftToMut<B>, A: VecZnxToRef, C: VmpPMatToRef<B>,

impl<B> VmpApplyDftTmpBytes for Module<B>

where B: Backend + VmpApplyDftTmpBytesImpl<B>,

fn vmp_apply_dft_tmp_bytes( &self, res_size: usize, a_size: usize, b_rows: usize, b_cols_in: usize, b_cols_out: usize, b_size: usize, ) -> usize

impl<B> VmpApplyDftToDft<B> for Module<B>

where B: Backend + VmpApplyDftToDftImpl<B>,

fn vmp_apply_dft_to_dft<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>,

Applies the vector matrix product crate::layouts::VecZnxDft x crate::layouts::VmpPMat.

impl<B> VmpApplyDftToDftAdd<B> for Module<B>

where B: Backend + VmpApplyDftToDftAddImpl<B>,

fn vmp_apply_dft_to_dft_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>,

impl<B> VmpApplyDftToDftAddTmpBytes for Module<B>

where B: Backend + VmpApplyDftToDftAddTmpBytesImpl<B>,

fn vmp_apply_dft_to_dft_add_tmp_bytes( &self, res_size: usize, a_size: usize, b_rows: usize, b_cols_in: usize, b_cols_out: usize, b_size: usize, ) -> usize

impl<B> VmpApplyDftToDftTmpBytes for Module<B>

where B: Backend + VmpApplyDftToDftTmpBytesImpl<B>,

fn vmp_apply_dft_to_dft_tmp_bytes( &self, res_size: usize, a_size: usize, b_rows: usize, b_cols_in: usize, b_cols_out: usize, b_size: usize, ) -> usize

impl<B> VmpPMatAlloc<B> for Module<B>

where B: Backend + VmpPMatAllocImpl<B>,

fn vmp_pmat_alloc( &self, rows: usize, cols_in: usize, cols_out: usize, size: usize, ) -> VmpPMatOwned<B>

impl<B> VmpPMatBytesOf for Module<B>

where B: Backend + VmpPMatAllocBytesImpl<B>,

fn bytes_of_vmp_pmat( &self, rows: usize, cols_in: usize, cols_out: usize, size: usize, ) -> usize

impl<B> VmpPMatFromBytes<B> for Module<B>

where B: Backend + VmpPMatFromBytesImpl<B>,

fn vmp_pmat_from_bytes( &self, rows: usize, cols_in: usize, cols_out: usize, size: usize, bytes: Vec<u8>, ) -> VmpPMatOwned<B>

impl<B> VmpPrepare<B> for Module<B>

where B: Backend + VmpPrepareImpl<B>,

fn vmp_prepare<R, A>(&self, res: &mut R, a: &A, scratch: &mut Scratch<B>)

where R: VmpPMatToMut<B>, A: MatZnxToRef,

impl<B> VmpPrepareTmpBytes for Module<B>

where B: Backend + VmpPrepareTmpBytesImpl<B>,

fn vmp_prepare_tmp_bytes( &self, rows: usize, cols_in: usize, cols_out: usize, size: usize, ) -> usize

impl<B> ZnAddNormal for Module<B>

where B: Backend + ZnAddNormalImpl<B>,

fn zn_add_normal<R>( &self, n: usize, base2k: usize, res: &mut R, res_col: usize, k: usize, source: &mut Source, sigma: f64, bound: f64, )

where R: ZnToMut,

Adds a discrete normal vector scaled by 2^{-k} with the provided standard deviation and bounded to [-bound, bound].

impl<B> ZnFillNormal for Module<B>

where B: Backend + ZnFillNormalImpl<B>,

fn zn_fill_normal<R>( &self, n: usize, base2k: usize, res: &mut R, res_col: usize, k: usize, source: &mut Source, sigma: f64, bound: f64, )

where R: ZnToMut,

impl<B> ZnFillUniform for Module<B>

where B: Backend + ZnFillUniformImpl<B>,

fn zn_fill_uniform<R>( &self, n: usize, base2k: usize, res: &mut R, res_col: usize, source: &mut Source, )

where R: ZnToMut,

Fills the first size size with uniform values in [-2^{base2k-1}, 2^{base2k-1}]

impl<B> ZnNormalizeInplace<B> for Module<B>

where B: Backend + ZnNormalizeInplaceImpl<B>,

fn zn_normalize_inplace<A>( &self, n: usize, base2k: usize, a: &mut A, a_col: usize, scratch: &mut Scratch<B>, )

where A: ZnToMut,

Normalizes the selected column of a.

impl<B> ZnNormalizeTmpBytes for Module<B>

where B: Backend + ZnNormalizeTmpBytesImpl<B>,

fn zn_normalize_tmp_bytes(&self, n: usize) -> usize

impl<B: Backend> Send for Module<B>

impl<B: Backend> Sync for Module<B>