Struct Module 

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

Primary entry point for all polynomial operations over Z[X]/(X^N + 1).

A Module pairs a ring degree N (always a power of two) with a backend-specific handle that holds any required precomputed state. All api trait methods are dispatched through this type.

The module owns its handle; dropping the Module calls Backend::destroy.

Implementations

impl<B> Module<B>

where B: Backend,

pub fn new(n: u64) -> Module<B>

where Module<B>: ModuleNew<B>,

Creates a backend module for ring degree N.

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

Creates a module from a NonNull backend handle.

Safety

ptr must point to a valid, fully initialized backend handle whose lifetime is transferred to this Module (it will be destroyed on drop).

pub unsafe fn from_raw_parts( ptr: *mut <B as Backend>::Handle, n: u64, ) -> Module<B>

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

Returns the raw pointer to the backend handle.

pub fn n(&self) -> usize

Returns the ring degree N.

pub fn scalar_znx_alloc( &self, cols: usize, ) -> ScalarZnx<<B as Backend>::OwnedBuf>

Allocates a zero-initialized backend-owned ScalarZnx.

pub fn vec_znx_alloc( &self, cols: usize, size: usize, ) -> VecZnx<<B as Backend>::OwnedBuf>

Allocates a zero-initialized backend-owned VecZnx.

pub fn vec_znx_alloc_with_max_size( &self, cols: usize, size: usize, max_size: usize, ) -> VecZnx<<B as Backend>::OwnedBuf>

Allocates a zero-initialized backend-owned VecZnx with explicit limb capacity.

pub fn mat_znx_alloc( &self, rows: usize, cols_in: usize, cols_out: usize, size: usize, ) -> MatZnx<<B as Backend>::OwnedBuf>

Allocates a zero-initialized backend-owned MatZnx.

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

Returns the raw pointer to the backend handle.

pub fn log_n(&self) -> usize

Returns log2(N).

pub fn reinterpret<Other>(&self) -> &Module<Other>

where Other: Backend<Handle = <B as Backend>::Handle>,

Reinterprets this Module<B> as a Module<Other> sharing the same backend Handle type.

This is a zero-cost view used to forward API calls to a compatible source backend without rebuilding the handle.

pub fn reinterpret_mut<Other>(&mut self) -> &mut Module<Other>

where Other: Backend<Handle = <B as Backend>::Handle>,

Mutable version of Module::reinterpret.

Trait Implementations

impl CKKSAddDefault<FFT64Ref> for Module<FFT64Ref>

fn ckks_add_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE> + GLWENormalize<BE>,

fn ckks_add_pt_vec_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshTmpBytes,

fn ckks_add_pt_const_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshTmpBytes,

fn ckks_add_into_default<Dst, A, B>( &self, dst: &mut Dst, a: &A, b: &B, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAdd<BE> + GLWEShift<BE> + GLWENormalize<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + SetCKKSInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, B: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_into_unsafe_default<Dst, A, B>( &self, dst: &mut Dst, a: &A, b: &B, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAdd<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + SetCKKSInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, B: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_assign_default<Dst, A>( &self, dst: &mut Dst, a: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAdd<BE> + GLWEShift<BE> + GLWENormalize<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSInfos,

fn ckks_add_assign_unsafe_default<Dst, A>( &self, dst: &mut Dst, a: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAdd<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSInfos,

fn ckks_add_one_assign_default<Dst>( &self, dst: &mut Dst, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWENormalize<BE> + VecZnxRshAddCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_vec_into_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddIntoBackend<BE> + GLWEShift<BE> + GLWENormalize<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_vec_into_unsafe_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddIntoBackend<BE> + GLWEShift<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_vec_assign_default<Dst, P>( &self, dst: &mut Dst, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddIntoBackend<BE> + GLWENormalize<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_vec_assign_unsafe_default<Dst, P>( &self, dst: &mut Dst, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_const_into_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshAddCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_const_into_unsafe_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE> + VecZnxRshAddCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_const_assign_default<Dst, P>( &self, dst: &mut Dst, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWENormalize<BE> + VecZnxRshAddCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_const_assign_unsafe_default<Dst, P>( &self, dst: &mut Dst, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

impl CKKSAddDefault<NTT120Ref> for Module<NTT120Ref>

fn ckks_add_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE> + GLWENormalize<BE>,

fn ckks_add_pt_vec_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshTmpBytes,

fn ckks_add_pt_const_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshTmpBytes,

fn ckks_add_into_default<Dst, A, B>( &self, dst: &mut Dst, a: &A, b: &B, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAdd<BE> + GLWEShift<BE> + GLWENormalize<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + SetCKKSInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, B: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_into_unsafe_default<Dst, A, B>( &self, dst: &mut Dst, a: &A, b: &B, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAdd<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + SetCKKSInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, B: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_assign_default<Dst, A>( &self, dst: &mut Dst, a: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAdd<BE> + GLWEShift<BE> + GLWENormalize<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSInfos,

fn ckks_add_assign_unsafe_default<Dst, A>( &self, dst: &mut Dst, a: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAdd<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSInfos,

fn ckks_add_one_assign_default<Dst>( &self, dst: &mut Dst, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWENormalize<BE> + VecZnxRshAddCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_vec_into_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddIntoBackend<BE> + GLWEShift<BE> + GLWENormalize<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_vec_into_unsafe_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddIntoBackend<BE> + GLWEShift<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_vec_assign_default<Dst, P>( &self, dst: &mut Dst, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddIntoBackend<BE> + GLWENormalize<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_vec_assign_unsafe_default<Dst, P>( &self, dst: &mut Dst, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_const_into_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshAddCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_const_into_unsafe_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE> + VecZnxRshAddCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_const_assign_default<Dst, P>( &self, dst: &mut Dst, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWENormalize<BE> + VecZnxRshAddCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_const_assign_unsafe_default<Dst, P>( &self, dst: &mut Dst, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

impl<BE> CKKSAddManyOps<BE> for Module<BE>

where BE: Backend, Module<BE>: CKKSAddOps<BE> + CKKSRescaleOps<BE>,

fn ckks_add_many_tmp_bytes(&self) -> usize

fn ckks_add_many<Dst, Src>( &self, dst: &mut CKKSCiphertext<Dst>, inputs: &[&CKKSCiphertext<Src>], scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, Src: Data, CKKSCiphertext<Dst>: GLWEToBackendMut<BE>, CKKSCiphertext<Src>: GLWEToBackendRef<BE>,

Computes dst = inputs[0] + inputs[1] + … + inputs[n-1] using a balanced binary tree of pairwise additions.

impl<BE> CKKSAddOps<BE> for Module<BE>

where BE: Backend + CKKSAddImpl<BE>,

fn ckks_add_tmp_bytes(&self) -> usize

fn ckks_add_into<Dst, A, B>( &self, dst: &mut Dst, a: &A, b: &B, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds, B: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = a + b.

fn ckks_add_assign<Dst, A>( &self, dst: &mut Dst, a: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst += a in-place.

fn ckks_add_one_assign<Dst>( &self, dst: &mut Dst, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos,

Computes dst += 1 in-place.

fn ckks_add_pt_vec_tmp_bytes(&self) -> usize

fn ckks_add_pt_vec_into<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = a + pt where pt is a full plaintext polynomial.

fn ckks_add_pt_vec_assign<Dst, P>( &self, dst: &mut Dst, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst += pt in-place, where pt is a full plaintext polynomial.

fn ckks_add_pt_const_tmp_bytes(&self) -> usize

fn ckks_add_pt_const_into<Dst, A, P>( &self, dst: &mut Dst, a: &A, dst_coeff: usize, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = a + pt[pt_coeff], adding one quantized constant to a single coefficient slot of the ciphertext.

fn ckks_add_pt_const_assign<Dst, P>( &self, dst: &mut Dst, dst_coeff: usize, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst += pt[pt_coeff] in-place.

impl<BE> CKKSAddOpsUnnormalized<BE> for Module<BE>

where BE: Backend + CKKSAddImpl<BE>,

fn ckks_add_into_unnormalized<Dst, A, B>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, a: &A, b: &B, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE> + CKKSCtBounds, B: GLWEToBackendRef<BE> + CKKSCtBounds,

fn ckks_add_assign_unnormalized<Dst, A>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, a: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE> + CKKSInfos,

fn ckks_add_pt_vec_into_unnormalized<Dst, A, P>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

fn ckks_add_pt_vec_assign_unnormalized<Dst, P>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, P: GLWEToBackendRef<BE> + CKKSCtBounds,

fn ckks_add_pt_const_into_unnormalized<Dst, A, P>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, a: &A, dst_coeff: usize, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

fn ckks_add_pt_const_assign_unnormalized<Dst, P>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, dst_coeff: usize, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, P: GLWEToBackendRef<BE> + CKKSCtBounds,

impl<BE> CKKSAffineOps<BE> for Module<BE>

where BE: Backend, Module<BE>: CKKSAddOps<BE> + CKKSMulOps<BE>,

fn ckks_affine_pt_const_tmp_bytes<R, A, P>( &self, res: &R, a: &A, affine_const: &P, ) -> usize

where R: CKKSCtBounds, A: CKKSCtBounds, P: CKKSInfos,

fn ckks_affine_pt_const_into<Dst, A, P>( &self, dst: &mut Dst, a: &A, affine_const: &P, offset_coeff: usize, scale_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = a * affine_const[scale_coeff] + affine_const[offset_coeff].

fn ckks_affine_pt_const_assign<Dst, P>( &self, dst: &mut Dst, affine_const: &P, offset_coeff: usize, scale_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + GLWEToBackendRef<BE> + CKKSCtBounds + SetCKKSInfos, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = dst * affine_const[scale_coeff] + affine_const[offset_coeff] in-place.

fn ckks_affine_pt_vec_tmp_bytes<R, A, S>( &self, res: &R, a: &A, scale: &S, ) -> usize

where R: CKKSCtBounds, A: CKKSCtBounds, S: CKKSInfos,

fn ckks_affine_pt_vec_into<Dst, A, S, P>( &self, dst: &mut Dst, a: &A, scale: &S, offset: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds, S: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = a * scale + offset where scale and offset are full plaintext polynomials in the ZNX domain.

fn ckks_affine_pt_vec_assign<Dst, S, P>( &self, dst: &mut Dst, scale: &S, offset: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + GLWEToBackendRef<BE> + CKKSCtBounds + SetCKKSInfos, S: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = dst * scale + offset in-place.

impl<BE> CKKSAllOpsTmpBytes<BE> for Module<BE>

where BE: Backend, Module<BE>: CKKSEncrypt<BE> + CKKSDecrypt<BE> + CKKSAddOps<BE> + CKKSConjugateOps<BE> + CKKSSubOps<BE> + CKKSNegOps<BE> + CKKSPow2Ops<BE> + CKKSImagOps<BE> + CKKSRescaleOps<BE> + CKKSRotateOps<BE> + CKKSMulOps<BE> + GLWEAutomorphism<BE> + GLWEAutomorphismKeyEncryptSk<BE> + GLWEAutomorphismKeyPreparedFactory<BE> + ModuleN + GLWEShift<BE> + GLWEMulPlain<BE> + GLWEMulConst<BE> + GLWERotate<BE> + GLWETensoring<BE> + GLWETensorKeyEncryptSk<BE> + GLWETensorKeyPreparedFactory<BE> + VecZnxLshBackend<BE> + VecZnxLshTmpBytes + VecZnxRshBackend<BE> + VecZnxRshAddIntoBackend<BE> + VecZnxRshSubBackend<BE> + VecZnxRshTmpBytes,

fn ckks_all_ops_tmp_bytes<C, T, P>( &self, ct_infos: &C, tsk_infos: &T, pt_prec: &P, ) -> usize

where C: CKKSCtBounds, T: GGLWEInfos, P: CKKSInfos,

Returns a scratch size large enough for the common CKKS workflow using ciphertext ops, plaintext ops, encryption/decryption, multiplication, and tensor-key setup.

fn ckks_all_ops_with_atk_tmp_bytes<C, T, A, P>( &self, ct_infos: &C, tsk_infos: &T, atk_infos: &A, pt_prec: &P, ) -> usize

where C: CKKSCtBounds, T: GGLWEInfos, A: GGLWEInfos, P: CKKSInfos,

Returns a scratch size large enough for Self::ckks_all_ops_tmp_bytes plus automorphism-key setup, rotation, and conjugation.

impl CKKSConjugateDefault<FFT64Ref> for Module<FFT64Ref>

fn ckks_conjugate_tmp_bytes_default<C, K>( &self, ct_infos: &C, key_infos: &K, ) -> usize

where C: GLWEInfos, K: GGLWEInfos, Self: GLWEAutomorphism<BE>,

fn ckks_conjugate_into_default<Dst, Src, K>( &self, dst: &mut Dst, src: &Src, key: &K, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAutomorphism<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + GLWEInfos + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

fn ckks_conjugate_assign_default<Dst, K>( &self, dst: &mut Dst, key: &K, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAutomorphism<BE>, Dst: GLWEToBackendMut<BE> + GLWEInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

impl CKKSConjugateDefault<NTT120Ref> for Module<NTT120Ref>

fn ckks_conjugate_tmp_bytes_default<C, K>( &self, ct_infos: &C, key_infos: &K, ) -> usize

where C: GLWEInfos, K: GGLWEInfos, Self: GLWEAutomorphism<BE>,

fn ckks_conjugate_into_default<Dst, Src, K>( &self, dst: &mut Dst, src: &Src, key: &K, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAutomorphism<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + GLWEInfos + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

fn ckks_conjugate_assign_default<Dst, K>( &self, dst: &mut Dst, key: &K, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAutomorphism<BE>, Dst: GLWEToBackendMut<BE> + GLWEInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

impl<BE> CKKSConjugateOps<BE> for Module<BE>

where BE: Backend + CKKSConjugateImpl<BE>, Module<BE>: GLWEAutomorphism<BE> + GLWEShift<BE>,

fn ckks_conjugate_tmp_bytes<C, K>(&self, ct_infos: &C, key_infos: &K) -> usize

where C: CKKSCtBounds, K: GGLWEInfos,

fn ckks_conjugate_into<Dst, Src, K>( &self, dst: &mut Dst, src: &Src, key: &K, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, Src: GLWEToBackendRef<BE> + CKKSCtBounds, K: GLWEAutomorphismKeyPreparedToBackendRef<BE> + GGLWEPreparedToBackendRef<BE> + GetGaloisElement + GGLWEInfos,

Computes dst = conj(src): takes the complex conjugate of every slot.

fn ckks_conjugate_assign<Dst, K>( &self, dst: &mut Dst, key: &K, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, K: GLWEAutomorphismKeyPreparedToBackendRef<BE> + GGLWEPreparedToBackendRef<BE> + GetGaloisElement + GGLWEInfos,

Computes dst = conj(dst) in-place. Metadata is unchanged.

impl CKKSCopyDefault<FFT64Ref> for Module<FFT64Ref>

fn ckks_copy_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE>,

fn ckks_copy_default<Dst, Src>( &self, dst: &mut Dst, src: &Src, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWECopy<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

impl CKKSCopyDefault<NTT120Ref> for Module<NTT120Ref>

fn ckks_copy_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE>,

fn ckks_copy_default<Dst, Src>( &self, dst: &mut Dst, src: &Src, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWECopy<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

impl<BE> CKKSCopyOps<BE> for Module<BE>

where BE: Backend + CKKSCopyImpl<BE>, Module<BE>: GLWECopy<BE> + GLWEShift<BE>,

fn ckks_copy_tmp_bytes(&self) -> usize

fn ckks_copy<Dst, Src>( &self, dst: &mut Dst, src: &Src, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, Src: GLWEToBackendRef<BE> + CKKSCtBounds,

Copies src into dst.

impl<BE> CKKSDecrypt<BE> for Module<BE>

where BE: Backend + CKKSEncryptionImpl<BE> + HalVecZnxImpl<BE>, Module<BE>: GLWEDecrypt<BE> + VecZnxLshBackend<BE> + VecZnxLshTmpBytes + VecZnxRshBackend<BE> + VecZnxRshTmpBytes + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf>, <BE as Backend>::OwnedBuf: HostDataMut,

fn ckks_decrypt_tmp_bytes<A>(&self, ct_infos: &A) -> usize

where A: CKKSCtBounds,

fn ckks_decrypt<Dpt, Dct, S>( &self, pt: &mut Dpt, ct: &Dct, sk: &S, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where S: GLWESecretPreparedToBackendRef<BE> + GLWEInfos, Dpt: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, Dct: GLWEToBackendRef<BE> + CKKSCtBounds,

impl<BE> CKKSDotProductOps<BE> for Module<BE>

where BE: Backend + CKKSAddImpl<BE>, Module<BE>: CKKSAddOps<BE> + CKKSMulOps<BE> + CKKSRescaleOps<BE> + GLWENormalize<BE> + GLWETensoring<BE>,

fn ckks_dot_product_ct_tmp_bytes<R, T>( &self, n: usize, res: &R, tsk: &T, ) -> usize

where R: CKKSCtBounds, T: GGLWEInfos,

fn ckks_dot_product_pt_vec_tmp_bytes<R, A, P>( &self, res: &R, a: &A, b: &P, ) -> usize

where R: CKKSCtBounds, A: CKKSCtBounds, P: CKKSInfos,

fn ckks_dot_product_pt_const_tmp_bytes<R, A, P>( &self, res: &R, a: &A, b: &P, ) -> usize

where R: CKKSCtBounds, A: CKKSCtBounds, P: CKKSInfos,

fn ckks_dot_product_ct<Dst, D, E, T>( &self, dst: &mut CKKSCiphertext<Dst>, a: &[&CKKSCiphertext<D>], b: &[&CKKSCiphertext<E>], tsk: &GLWETensorKeyPrepared<T, BE>, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, D: Data, E: Data, T: Data, CKKSCiphertext<Dst>: GLWEToBackendMut<BE>, CKKSCiphertext<D>: GLWEToBackendRef<BE> + GLWEInfos, CKKSCiphertext<E>: GLWEToBackendRef<BE> + GLWEInfos, GLWETensorKeyPrepared<T, BE>: GLWETensorKeyPreparedToBackendRef<BE>,

Computes dst = Σ a[i] * b[i] over ciphertext–ciphertext pairs.

fn ckks_dot_product_pt_vec<Dst, D, E>( &self, dst: &mut CKKSCiphertext<Dst>, a: &[&CKKSCiphertext<D>], b: &[&E], scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, D: Data, CKKSCiphertext<Dst>: GLWEToBackendMut<BE>, CKKSCiphertext<D>: GLWEToBackendRef<BE> + GLWEInfos, E: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = Σ a[i] * b[i] over ciphertext–plaintext-polynomial pairs.

fn ckks_dot_product_pt_const<Dst, D, E>( &self, dst: &mut CKKSCiphertext<Dst>, a: &[&CKKSCiphertext<D>], b: &[&E], pt_coeffs: &[usize], scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, D: Data, CKKSCiphertext<Dst>: GLWEToBackendMut<BE>, CKKSCiphertext<D>: GLWEToBackendRef<BE> + GLWEInfos, E: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = Σ a[i] * b[i][pt_coeffs[i]] over ciphertext–scalar-constant pairs.

impl<BE> CKKSEncrypt<BE> for Module<BE>

where BE: Backend + CKKSEncryptionImpl<BE> + HalVecZnxImpl<BE>, Module<BE>: GLWEEncryptSk<BE> + VecZnxRshAddIntoBackend<BE> + VecZnxRshTmpBytes,

fn ckks_encrypt_sk_tmp_bytes<A>(&self, ct_infos: &A) -> usize

where A: CKKSCtBounds,

fn ckks_encrypt_sk<Dct, Dpt, S, E>( &self, ct: &mut Dct, pt: &Dpt, sk: &S, enc_infos: &E, source_xa: &mut Source, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>, Dct: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, Dpt: GLWEToBackendRef<BE> + CKKSCtBounds,

impl CKKSEncryptionDefault<FFT64Ref> for Module<FFT64Ref>

fn ckks_encrypt_sk_tmp_bytes_default<A>(&self, ct_infos: &A) -> usize

where A: GLWEInfos + CKKSInfos, Self: GLWEEncryptSk<BE> + VecZnxRshAddIntoBackend<BE> + VecZnxRshTmpBytes,

fn ckks_encrypt_sk_default<Dct, Dpt, S, E>( &self, ct: &mut Dct, pt: &Dpt, sk: &S, enc_infos: &E, source_xa: &mut Source, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>, Dct: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Dpt: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, Self: GLWEEncryptSk<BE> + VecZnxRshAddIntoBackend<BE> + CKKSPlaintextDefault<BE>,

fn ckks_decrypt_tmp_bytes_default<A>(&self, ct_infos: &A) -> usize

where A: GLWEInfos + CKKSInfos, Self: GLWEDecrypt<BE> + VecZnxLshBackend<BE> + VecZnxLshTmpBytes + VecZnxRshBackend<BE> + VecZnxRshTmpBytes + CKKSPlaintextDefault<BE>,

fn ckks_decrypt_default<Dpt, Dct, S>( &self, pt: &mut Dpt, ct: &Dct, sk: &S, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where S: GLWESecretPreparedToBackendRef<BE> + GLWEInfos, Dpt: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Dct: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos, Self: GLWEDecrypt<BE> + CKKSPlaintextDefault<BE> + VecZnxLshBackend<BE> + VecZnxRshBackend<BE>,

impl CKKSEncryptionDefault<NTT120Ref> for Module<NTT120Ref>

fn ckks_encrypt_sk_tmp_bytes_default<A>(&self, ct_infos: &A) -> usize

where A: GLWEInfos + CKKSInfos, Self: GLWEEncryptSk<BE> + VecZnxRshAddIntoBackend<BE> + VecZnxRshTmpBytes,

fn ckks_encrypt_sk_default<Dct, Dpt, S, E>( &self, ct: &mut Dct, pt: &Dpt, sk: &S, enc_infos: &E, source_xa: &mut Source, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>, Dct: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Dpt: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, Self: GLWEEncryptSk<BE> + VecZnxRshAddIntoBackend<BE> + CKKSPlaintextDefault<BE>,

fn ckks_decrypt_tmp_bytes_default<A>(&self, ct_infos: &A) -> usize

where A: GLWEInfos + CKKSInfos, Self: GLWEDecrypt<BE> + VecZnxLshBackend<BE> + VecZnxLshTmpBytes + VecZnxRshBackend<BE> + VecZnxRshTmpBytes + CKKSPlaintextDefault<BE>,

fn ckks_decrypt_default<Dpt, Dct, S>( &self, pt: &mut Dpt, ct: &Dct, sk: &S, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where S: GLWESecretPreparedToBackendRef<BE> + GLWEInfos, Dpt: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Dct: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos, Self: GLWEDecrypt<BE> + CKKSPlaintextDefault<BE> + VecZnxLshBackend<BE> + VecZnxRshBackend<BE>,

impl CKKSImagDefault<FFT64Ref> for Module<FFT64Ref>

fn ckks_mul_i_tmp_bytes_default(&self) -> usize

where Self: GLWERotate<BE> + GLWEShift<BE>,

fn ckks_div_i_tmp_bytes_default(&self) -> usize

where Self: GLWERotate<BE> + GLWEShift<BE>,

fn ckks_mul_i_into_default<Dst, Src>( &self, dst: &mut Dst, src: &Src, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWERotate<BE> + GLWEShift<BE> + ModuleN, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos,

fn ckks_mul_i_assign_default<Dst>( &self, dst: &mut Dst, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWERotate<BE> + ModuleN, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos,

fn ckks_div_i_into_default<Dst, Src>( &self, dst: &mut Dst, src: &Src, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWECopy<BE> + GLWENegate<BE> + GLWERotate<BE> + GLWEShift<BE> + ModuleN, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos,

fn ckks_div_i_assign_default<Dst>( &self, dst: &mut Dst, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWENegate<BE> + GLWERotate<BE> + ModuleN, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos,

impl CKKSImagDefault<NTT120Ref> for Module<NTT120Ref>

fn ckks_mul_i_tmp_bytes_default(&self) -> usize

where Self: GLWERotate<BE> + GLWEShift<BE>,

fn ckks_div_i_tmp_bytes_default(&self) -> usize

where Self: GLWERotate<BE> + GLWEShift<BE>,

fn ckks_mul_i_into_default<Dst, Src>( &self, dst: &mut Dst, src: &Src, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWERotate<BE> + GLWEShift<BE> + ModuleN, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos,

fn ckks_mul_i_assign_default<Dst>( &self, dst: &mut Dst, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWERotate<BE> + ModuleN, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos,

fn ckks_div_i_into_default<Dst, Src>( &self, dst: &mut Dst, src: &Src, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWECopy<BE> + GLWENegate<BE> + GLWERotate<BE> + GLWEShift<BE> + ModuleN, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos,

fn ckks_div_i_assign_default<Dst>( &self, dst: &mut Dst, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWENegate<BE> + GLWERotate<BE> + ModuleN, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos,

impl<BE> CKKSImagOps<BE> for Module<BE>

where BE: Backend + CKKSImagImpl<BE>, Module<BE>: GLWECopy<BE> + GLWENegate<BE> + GLWERotate<BE> + GLWEShift<BE> + ModuleN,

fn ckks_mul_i_tmp_bytes(&self) -> usize

fn ckks_mul_i_into<Dst, Src>( &self, dst: &mut Dst, src: &Src, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, Src: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = i · src (multiply every slot by the imaginary unit).

fn ckks_mul_i_assign<Dst>( &self, dst: &mut Dst, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos,

Computes dst = i · dst in-place. Metadata is unchanged.

fn ckks_div_i_tmp_bytes(&self) -> usize

fn ckks_div_i_into<Dst, Src>( &self, dst: &mut Dst, src: &Src, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, Src: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = src / i = −i · src (multiply every slot by −i).

fn ckks_div_i_assign<Dst>( &self, dst: &mut Dst, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos,

Computes dst = dst / i in-place. Metadata is unchanged.

impl<BE> CKKSMaintainOps for Module<BE>

where BE: Backend<OwnedBuf = Vec<u8>> + HostBackend, Module<BE>: CKKSMaintainOpsDefault<BE> + CKKSModuleAlloc<BE>,

fn ckks_reallocate_limbs_checked( &self, ct: &mut CKKSCiphertext<Vec<u8>>, size: usize, ) -> Result<(), Error>

Reallocates the owned backing buffer to exactly size limbs.

fn ckks_compact_limbs( &self, ct: &mut CKKSCiphertext<Vec<u8>>, ) -> Result<(), Error>

Shrinks an owned ciphertext buffer to the minimum limb count that still preserves its current metadata.

fn ckks_compact_limbs_copy<D>( &self, ct: &CKKSCiphertext<D>, ) -> Result<CKKSCiphertext<Vec<u8>>, Error>

where D: HostDataRef,

Returns a newly allocated owned ciphertext holding a compacted copy of ct.

impl<BE> CKKSModuleAlloc<BE> for Module<BE>

where BE: Backend, Module<BE>: ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf>,

fn ckks_ciphertext_alloc_from_infos<A>( &self, infos: &A, ) -> CKKSCiphertext<<BE as Backend>::OwnedBuf>

where A: GLWEInfos,

fn ckks_ciphertext_alloc( &self, base2k: Base2K, k: TorusPrecision, ) -> CKKSCiphertext<<BE as Backend>::OwnedBuf>

fn ckks_pt_vec_alloc_from_infos<A>( &self, infos: &A, ) -> CKKSPlaintext<<BE as Backend>::OwnedBuf>

where A: GLWEInfos + CKKSInfos,

fn ckks_plaintext_alloc_from_infos<A>( &self, infos: &A, ) -> CKKSPlaintext<<BE as Backend>::OwnedBuf>

where A: LWEInfos + CKKSInfos,

fn ckks_plaintext_alloc( &self, n: Degree, base2k: Base2K, meta: CKKSMeta, ) -> CKKSPlaintext<<BE as Backend>::OwnedBuf>

fn ckks_pt_vec_alloc( &self, base2k: Base2K, meta: CKKSMeta, ) -> CKKSPlaintext<<BE as Backend>::OwnedBuf>

fn ckks_pt_coeffs_alloc( &self, coeff_count: usize, base2k: Base2K, meta: CKKSMeta, ) -> CKKSPlaintext<<BE as Backend>::OwnedBuf>

impl<BE> CKKSMulAddOps<BE> for Module<BE>

where BE: Backend, Module<BE>: CKKSAddOps<BE> + CKKSMulOps<BE> + CKKSAddOpsUnnormalized<BE>,

fn ckks_mul_add_ct_tmp_bytes<R, T>(&self, res: &R, tsk: &T) -> usize

where R: CKKSCtBounds, T: GGLWEInfos,

fn ckks_mul_add_pt_vec_tmp_bytes<R, A, P>(&self, res: &R, a: &A, b: &P) -> usize

where R: CKKSCtBounds, A: CKKSCtBounds, P: CKKSInfos,

fn ckks_mul_add_pt_const_tmp_bytes<R, A, P>( &self, res: &R, a: &A, b: &P, ) -> usize

where R: CKKSCtBounds, A: CKKSCtBounds, P: CKKSInfos,

fn ckks_mul_add_ct_into<Dst, A, B, T>( &self, dst: &mut CKKSCiphertext<Dst>, a: &CKKSCiphertext<A>, b: &CKKSCiphertext<B>, tsk: &GLWETensorKeyPrepared<T, BE>, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, A: Data, B: Data, T: Data, CKKSCiphertext<Dst>: GLWEToBackendMut<BE>, CKKSCiphertext<A>: GLWEToBackendRef<BE> + GLWEInfos, CKKSCiphertext<B>: GLWEToBackendRef<BE> + GLWEInfos, GLWETensorKeyPrepared<T, BE>: GLWETensorKeyPreparedToBackendRef<BE>,

Computes dst += a * b using tensor-product keyswitching via tsk.

fn ckks_mul_add_pt_vec_into<Dst, A, P>( &self, dst: &mut CKKSCiphertext<Dst>, a: &CKKSCiphertext<A>, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, A: Data, CKKSCiphertext<Dst>: GLWEToBackendMut<BE>, CKKSCiphertext<A>: GLWEToBackendRef<BE> + GLWEInfos, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst += a * pt where pt is a full plaintext polynomial.

fn ckks_mul_add_pt_const_into<Dst, A, P>( &self, dst: &mut CKKSCiphertext<Dst>, a: &CKKSCiphertext<A>, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, A: Data, CKKSCiphertext<Dst>: GLWEToBackendMut<BE>, CKKSCiphertext<A>: GLWEToBackendRef<BE> + GLWEInfos, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst += a * pt[pt_coeff].

fn ckks_mul_add_pt_const_into_unnormalized<Dst, A, P>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, a: &A, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst += a * pt[pt_coeff] without normalizing dst.

fn ckks_mul_add_pt_vec_into_unnormalized<Dst, A, P>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst += a * pt without normalizing dst.

impl CKKSMulDefault<FFT64Ref> for Module<FFT64Ref>

fn ckks_mul_tmp_bytes_default<R, T>(&self, res: &R, tsk: &T) -> usize

where R: GLWEInfos, T: GGLWEInfos, Self: GLWETensoring<BE>,

fn ckks_mul_into_default<Dst, A, B, T>( &self, dst: &mut Dst, a: &A, b: &B, tsk: &T, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWETensoring<BE> + GLWECopy<BE> + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + GLWEInfos, B: GLWEToBackendRef<BE> + CKKSInfos + GLWEInfos, T: GLWETensorKeyPreparedToBackendRef<BE> + GGLWEInfos,

fn ckks_mul_assign_default<Dst, A, T>( &self, dst: &mut Dst, a: &A, tsk: &T, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWETensoring<BE> + GLWECopy<BE> + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf>, Dst: GLWEToBackendMut<BE> + GLWEToBackendRef<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + GLWEInfos, T: GLWETensorKeyPreparedToBackendRef<BE> + GGLWEInfos,

fn ckks_square_tmp_bytes_default<R, T>(&self, res: &R, tsk: &T) -> usize

where R: GLWEInfos, T: GGLWEInfos, Self: GLWETensoring<BE>,

fn ckks_square_into_default<Dst, A, T>( &self, dst: &mut Dst, a: &A, tsk: &T, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWETensoring<BE> + GLWECopy<BE> + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + GLWEInfos, T: GLWETensorKeyPreparedToBackendRef<BE> + GGLWEInfos,

fn ckks_square_assign_default<Dst, T>( &self, dst: &mut Dst, tsk: &T, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWETensoring<BE> + GLWECopy<BE> + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf>, Dst: GLWEToBackendMut<BE> + GLWEToBackendRef<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos, T: GLWETensorKeyPreparedToBackendRef<BE> + GGLWEInfos,

fn ckks_mul_pt_vec_tmp_bytes_default<R, A>( &self, res: &R, a: &A, b: &CKKSMeta, ) -> usize

where R: GLWEInfos, A: GLWEInfos, Self: GLWEMulPlain<BE>,

fn ckks_mul_pt_const_tmp_bytes_default<R, A>( &self, res: &R, a: &A, b: &CKKSMeta, ) -> usize

where R: GLWEInfos, A: GLWEInfos, Self: GLWEMulConst<BE> + GLWERotate<BE>,

fn ckks_mul_pt_vec_into_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where P: GLWEToBackendRef<BE> + LWEInfos + GLWEInfos + CKKSInfos, Self: GLWECopy<BE> + GLWEMulPlain<BE> + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf> + VecZnxCopyBackend<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + GLWEInfos,

fn ckks_mul_pt_vec_assign_default<Dst, P>( &self, dst: &mut Dst, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where P: GLWEToBackendRef<BE> + LWEInfos + GLWEInfos + CKKSInfos, Self: GLWECopy<BE> + GLWEMulPlain<BE> + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf> + VecZnxCopyBackend<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos,

fn ckks_mul_pt_const_into_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where P: GLWEToBackendRef<BE> + LWEInfos + GLWEInfos + CKKSInfos, Self: GLWEMulConst<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + GLWEInfos,

fn ckks_mul_pt_const_assign_default<Dst, P>( &self, dst: &mut Dst, cnst: &P, cnst_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where P: GLWEToBackendRef<BE> + LWEInfos + GLWEInfos + CKKSInfos, Self: GLWEMulConst<BE>, Dst: GLWEToBackendMut<BE> + GLWEToBackendRef<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos,

impl CKKSMulDefault<NTT120Ref> for Module<NTT120Ref>

fn ckks_mul_tmp_bytes_default<R, T>(&self, res: &R, tsk: &T) -> usize

where R: GLWEInfos, T: GGLWEInfos, Self: GLWETensoring<BE>,

fn ckks_mul_into_default<Dst, A, B, T>( &self, dst: &mut Dst, a: &A, b: &B, tsk: &T, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWETensoring<BE> + GLWECopy<BE> + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + GLWEInfos, B: GLWEToBackendRef<BE> + CKKSInfos + GLWEInfos, T: GLWETensorKeyPreparedToBackendRef<BE> + GGLWEInfos,

fn ckks_mul_assign_default<Dst, A, T>( &self, dst: &mut Dst, a: &A, tsk: &T, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWETensoring<BE> + GLWECopy<BE> + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf>, Dst: GLWEToBackendMut<BE> + GLWEToBackendRef<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + GLWEInfos, T: GLWETensorKeyPreparedToBackendRef<BE> + GGLWEInfos,

fn ckks_square_tmp_bytes_default<R, T>(&self, res: &R, tsk: &T) -> usize

where R: GLWEInfos, T: GGLWEInfos, Self: GLWETensoring<BE>,

fn ckks_square_into_default<Dst, A, T>( &self, dst: &mut Dst, a: &A, tsk: &T, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWETensoring<BE> + GLWECopy<BE> + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + GLWEInfos, T: GLWETensorKeyPreparedToBackendRef<BE> + GGLWEInfos,

fn ckks_square_assign_default<Dst, T>( &self, dst: &mut Dst, tsk: &T, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWETensoring<BE> + GLWECopy<BE> + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf>, Dst: GLWEToBackendMut<BE> + GLWEToBackendRef<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos, T: GLWETensorKeyPreparedToBackendRef<BE> + GGLWEInfos,

fn ckks_mul_pt_vec_tmp_bytes_default<R, A>( &self, res: &R, a: &A, b: &CKKSMeta, ) -> usize

where R: GLWEInfos, A: GLWEInfos, Self: GLWEMulPlain<BE>,

fn ckks_mul_pt_const_tmp_bytes_default<R, A>( &self, res: &R, a: &A, b: &CKKSMeta, ) -> usize

where R: GLWEInfos, A: GLWEInfos, Self: GLWEMulConst<BE> + GLWERotate<BE>,

fn ckks_mul_pt_vec_into_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where P: GLWEToBackendRef<BE> + LWEInfos + GLWEInfos + CKKSInfos, Self: GLWECopy<BE> + GLWEMulPlain<BE> + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf> + VecZnxCopyBackend<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + GLWEInfos,

fn ckks_mul_pt_vec_assign_default<Dst, P>( &self, dst: &mut Dst, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where P: GLWEToBackendRef<BE> + LWEInfos + GLWEInfos + CKKSInfos, Self: GLWECopy<BE> + GLWEMulPlain<BE> + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf> + VecZnxCopyBackend<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos,

fn ckks_mul_pt_const_into_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where P: GLWEToBackendRef<BE> + LWEInfos + GLWEInfos + CKKSInfos, Self: GLWEMulConst<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + GLWEInfos,

fn ckks_mul_pt_const_assign_default<Dst, P>( &self, dst: &mut Dst, cnst: &P, cnst_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where P: GLWEToBackendRef<BE> + LWEInfos + GLWEInfos + CKKSInfos, Self: GLWEMulConst<BE>, Dst: GLWEToBackendMut<BE> + GLWEToBackendRef<BE> + CKKSInfos + SetCKKSInfos + GLWEInfos,

impl<BE> CKKSMulOps<BE> for Module<BE>

where BE: Backend + CKKSMulImpl<BE>, Module<BE>: GLWEAdd<BE> + GLWECopy<BE> + GLWEMulConst<BE> + GLWEMulPlain<BE> + GLWERotate<BE> + GLWETensoring<BE> + ModuleN + ModuleCoreAlloc<OwnedBuf = <BE as Backend>::OwnedBuf> + VecZnxCopyBackend<BE>,

fn ckks_mul_tmp_bytes<R, T>(&self, res: &R, tsk: &T) -> usize

where R: CKKSCtBounds, T: GGLWEInfos,

fn ckks_square_tmp_bytes<R, T>(&self, res: &R, tsk: &T) -> usize

where R: CKKSCtBounds, T: GGLWEInfos,

fn ckks_mul_pt_vec_tmp_bytes<R, A, P>(&self, res: &R, a: &A, b: &P) -> usize

where R: CKKSCtBounds, A: CKKSCtBounds, P: CKKSInfos,

fn ckks_mul_pt_const_tmp_bytes<R, A, P>(&self, res: &R, a: &A, b: &P) -> usize

where R: CKKSCtBounds, A: CKKSCtBounds, P: CKKSInfos,

fn ckks_mul_into<Dst, A, B, T>( &self, dst: &mut Dst, a: &A, b: &B, tsk: &T, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds, B: GLWEToBackendRef<BE> + CKKSCtBounds, T: GGLWEInfos + GLWETensorKeyPreparedToBackendRef<BE>,

Computes dst = a * b using tensor-product keyswitching via tsk.

fn ckks_mul_assign<Dst, A, T>( &self, dst: &mut Dst, a: &A, tsk: &T, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + GLWEToBackendRef<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds, T: GGLWEInfos + GLWETensorKeyPreparedToBackendRef<BE>,

Computes dst *= a in-place using tensor-product keyswitching via tsk.

fn ckks_square_into<Dst, A, T>( &self, dst: &mut Dst, a: &A, tsk: &T, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds, T: GGLWEInfos + GLWETensorKeyPreparedToBackendRef<BE>,

Computes dst = a * a (squaring) using tensor-product keyswitching.

fn ckks_square_assign<Dst, T>( &self, dst: &mut Dst, tsk: &T, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + GLWEToBackendRef<BE> + CKKSCtBounds + SetCKKSInfos, T: GGLWEInfos + GLWETensorKeyPreparedToBackendRef<BE>,

Computes dst = dst * dst (squaring in-place) using tensor-product keyswitching.

fn ckks_mul_pt_vec_into<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = a * pt where pt is a full plaintext polynomial.

fn ckks_mul_pt_vec_assign<Dst, P>( &self, dst: &mut Dst, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + GLWEToBackendRef<BE> + CKKSCtBounds + SetCKKSInfos, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst *= pt in-place.

fn ckks_mul_pt_const_into<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = a * pt[pt_coeff], multiplying by a single quantized constant from coefficient pt_coeff of pt.

fn ckks_mul_pt_const_assign<Dst, P>( &self, dst: &mut Dst, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + GLWEToBackendRef<BE> + CKKSCtBounds + SetCKKSInfos, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst *= pt[pt_coeff] in-place.

impl<BE> CKKSMulSubOps<BE> for Module<BE>

where BE: Backend, Module<BE>: CKKSMulOps<BE> + CKKSSubOps<BE>,

fn ckks_mul_sub_ct_tmp_bytes<R, T>(&self, res: &R, tsk: &T) -> usize

where R: CKKSCtBounds, T: GGLWEInfos,

fn ckks_mul_sub_pt_vec_tmp_bytes<R, A, P>(&self, res: &R, a: &A, b: &P) -> usize

where R: CKKSCtBounds, A: CKKSCtBounds, P: CKKSInfos,

fn ckks_mul_sub_pt_const_tmp_bytes<R, A, P>( &self, res: &R, a: &A, b: &P, ) -> usize

where R: CKKSCtBounds, A: CKKSCtBounds, P: CKKSInfos,

fn ckks_mul_sub_ct_into<Dst, A, B, T>( &self, dst: &mut CKKSCiphertext<Dst>, a: &CKKSCiphertext<A>, b: &CKKSCiphertext<B>, tsk: &GLWETensorKeyPrepared<T, BE>, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, A: Data, B: Data, T: Data, CKKSCiphertext<Dst>: GLWEToBackendMut<BE>, CKKSCiphertext<A>: GLWEToBackendRef<BE> + GLWEInfos, CKKSCiphertext<B>: GLWEToBackendRef<BE> + GLWEInfos, GLWETensorKeyPrepared<T, BE>: GLWETensorKeyPreparedToBackendRef<BE>,

Computes dst -= a * b using tensor-product keyswitching via tsk.

fn ckks_mul_sub_pt_vec_into<Dst, A, P>( &self, dst: &mut CKKSCiphertext<Dst>, a: &CKKSCiphertext<A>, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, A: Data, CKKSCiphertext<Dst>: GLWEToBackendMut<BE>, CKKSCiphertext<A>: GLWEToBackendRef<BE> + GLWEInfos, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst -= a * pt where pt is a full plaintext polynomial.

fn ckks_mul_sub_pt_const_into<Dst, A, P>( &self, dst: &mut CKKSCiphertext<Dst>, a: &CKKSCiphertext<A>, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, A: Data, CKKSCiphertext<Dst>: GLWEToBackendMut<BE>, CKKSCiphertext<A>: GLWEToBackendRef<BE> + GLWEInfos, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst -= a * pt[pt_coeff].

impl CKKSNegDefault<FFT64Ref> for Module<FFT64Ref>

fn ckks_neg_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE>,

fn ckks_neg_into_default<Dst, Src>( &self, dst: &mut Dst, src: &Src, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWENegate<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos,

fn ckks_neg_assign_default<Dst>(&self, dst: &mut Dst) -> Result<(), Error>

where Self: GLWENegate<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos,

impl CKKSNegDefault<NTT120Ref> for Module<NTT120Ref>

fn ckks_neg_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE>,

fn ckks_neg_into_default<Dst, Src>( &self, dst: &mut Dst, src: &Src, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWENegate<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos,

fn ckks_neg_assign_default<Dst>(&self, dst: &mut Dst) -> Result<(), Error>

where Self: GLWENegate<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos,

impl<BE> CKKSNegOps<BE> for Module<BE>

where BE: Backend + CKKSNegImpl<BE>, Module<BE>: GLWENegate<BE> + GLWEShift<BE>,

fn ckks_neg_tmp_bytes(&self) -> usize

fn ckks_neg_into<Dst, Src>( &self, dst: &mut Dst, src: &Src, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, Src: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = -src.

fn ckks_neg_assign<Dst>(&self, dst: &mut Dst) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos,

Computes dst = -dst in-place. Metadata is unchanged.

impl CKKSPlaintextDefault<FFT64Ref> for Module<FFT64Ref>

fn ckks_add_pt_vec_into_default<Dst, A>( &self, ct: &mut Dst, pt: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddIntoBackend<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_const_into_default<Dst, A>( &self, ct: &mut Dst, coeff_ct: usize, pt: &A, coeff_pt: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddCoeffIntoBackend<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_const_into_default<Dst, A>( &self, ct: &mut Dst, coeff_ct: usize, pt: &A, coeff_pt: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubCoeffIntoBackend<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_vec_into_default<Dst, A>( &self, ct: &mut Dst, pt: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubBackend<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_extract_pt_tmp_bytes_default(&self) -> usize

where Self: VecZnxLshTmpBytes + VecZnxRshTmpBytes,

fn ckks_extract_pt_default<D, S>( &self, dst: &mut D, src: &S, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where D: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, S: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos, Self: VecZnxLshBackend<BE> + VecZnxRshBackend<BE>,

fn ckks_extract_pt_with_meta_default<D, S>( &self, dst: &mut D, src: &S, src_meta: CKKSMeta, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where D: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, S: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos, Self: VecZnxLshBackend<BE> + VecZnxRshBackend<BE>,

impl CKKSPlaintextDefault<NTT120Ref> for Module<NTT120Ref>

fn ckks_add_pt_vec_into_default<Dst, A>( &self, ct: &mut Dst, pt: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddIntoBackend<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_add_pt_const_into_default<Dst, A>( &self, ct: &mut Dst, coeff_ct: usize, pt: &A, coeff_pt: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshAddCoeffIntoBackend<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_const_into_default<Dst, A>( &self, ct: &mut Dst, coeff_ct: usize, pt: &A, coeff_pt: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubCoeffIntoBackend<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_vec_into_default<Dst, A>( &self, ct: &mut Dst, pt: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubBackend<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_extract_pt_tmp_bytes_default(&self) -> usize

where Self: VecZnxLshTmpBytes + VecZnxRshTmpBytes,

fn ckks_extract_pt_default<D, S>( &self, dst: &mut D, src: &S, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where D: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, S: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos, Self: VecZnxLshBackend<BE> + VecZnxRshBackend<BE>,

fn ckks_extract_pt_with_meta_default<D, S>( &self, dst: &mut D, src: &S, src_meta: CKKSMeta, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where D: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, S: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos, Self: VecZnxLshBackend<BE> + VecZnxRshBackend<BE>,

impl<BE> CKKSPlaintextVecOps<BE> for Module<BE>

where BE: Backend + CKKSPlaintextZnxImpl<BE> + HalVecZnxImpl<BE>, Module<BE>: VecZnxLshBackend<BE> + VecZnxLshTmpBytes + VecZnxRshBackend<BE> + VecZnxRshTmpBytes,

fn ckks_extract_pt_tmp_bytes(&self) -> usize

fn ckks_extract_pt<D, S>( &self, dst: &mut D, src: &S, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where D: GLWEToBackendMut<BE> + GLWEInfos + CKKSInfos + SetCKKSInfos + LWEInfos, S: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos,

Extracts the ZNX plaintext polynomial from src into dst.

impl CKKSPow2Default<FFT64Ref> for Module<FFT64Ref>

fn ckks_mul_pow2_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE>,

fn ckks_div_pow2_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE>,

fn ckks_mul_pow2_into_default<Dst, Src>( &self, dst: &mut Dst, src: &Src, bits: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos,

fn ckks_mul_pow2_assign_default<Dst>( &self, dst: &mut Dst, bits: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos,

fn ckks_div_pow2_into_default<Dst, Src>( &self, dst: &mut Dst, src: &Src, bits: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE> + GLWECopy<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos,

fn ckks_div_pow2_assign_default<Dst>( &self, dst: &mut Dst, bits: usize, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos,

impl CKKSPow2Default<NTT120Ref> for Module<NTT120Ref>

fn ckks_mul_pow2_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE>,

fn ckks_div_pow2_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE>,

fn ckks_mul_pow2_into_default<Dst, Src>( &self, dst: &mut Dst, src: &Src, bits: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos,

fn ckks_mul_pow2_assign_default<Dst>( &self, dst: &mut Dst, bits: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos,

fn ckks_div_pow2_into_default<Dst, Src>( &self, dst: &mut Dst, src: &Src, bits: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE> + GLWECopy<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos,

fn ckks_div_pow2_assign_default<Dst>( &self, dst: &mut Dst, bits: usize, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + LWEInfos + CKKSInfos + SetCKKSInfos,

impl<BE> CKKSPow2Ops<BE> for Module<BE>

where BE: Backend + CKKSPow2Impl<BE>, Module<BE>: GLWECopy<BE> + GLWEShift<BE>,

fn ckks_mul_pow2_tmp_bytes(&self) -> usize

fn ckks_mul_pow2_into<Dst, Src>( &self, dst: &mut Dst, src: &Src, bits: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, Src: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = src * 2^bits.

fn ckks_mul_pow2_assign<Dst>( &self, dst: &mut Dst, bits: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos,

Computes dst *= 2^bits in-place. Metadata is unchanged.

fn ckks_div_pow2_tmp_bytes(&self) -> usize

fn ckks_div_pow2_into<Dst, Src>( &self, dst: &mut Dst, src: &Src, bits: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, Src: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = src / 2^bits.

fn ckks_div_pow2_assign<Dst>( &self, dst: &mut Dst, bits: usize, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos,

Computes dst /= 2^bits in-place.

impl<BE> CKKSRescaleOps<BE> for Module<BE>

where BE: Backend + CKKSRescaleImpl<BE>, Module<BE>: GLWEShift<BE>,

fn ckks_rescale_tmp_bytes(&self) -> usize

Returns scratch bytes required by Self::ckks_rescale_into.

fn ckks_rescale_assign<Dst>( &self, ct: &mut Dst, k: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos,

Rescales ct in-place by k bits.

fn ckks_rescale_into<Dst, Src>( &self, dst: &mut Dst, k: usize, src: &Src, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, Src: GLWEToBackendRef<BE> + CKKSCtBounds,

Writes a k-bit rescaled copy of src into dst.

fn ckks_align_pair<A, B>( &self, a: &mut A, b: &mut B, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where A: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, B: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos,

Equalizes the log_budget of a and b by rescaling whichever has more remaining capacity down to the other’s level.

fn ckks_align_tmp_bytes(&self) -> usize

Returns scratch bytes required by Self::ckks_align_pair.

impl CKKSRotateDefault<FFT64Ref> for Module<FFT64Ref>

fn ckks_rotate_tmp_bytes_default<C, K>( &self, ct_infos: &C, key_infos: &K, ) -> usize

where C: GLWEInfos, K: GGLWEInfos, Self: GLWEAutomorphism<BE>,

fn ckks_rotate_into_default<Dst, Src, K>( &self, dst: &mut Dst, src: &Src, key: &K, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAutomorphism<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + GLWEInfos + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

fn ckks_rotate_assign_default<Dst, K>( &self, dst: &mut Dst, key: &K, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAutomorphism<BE>, Dst: GLWEToBackendMut<BE> + GLWEInfos + LWEInfos + CKKSInfos + SetCKKSInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

impl CKKSRotateDefault<NTT120Ref> for Module<NTT120Ref>

fn ckks_rotate_tmp_bytes_default<C, K>( &self, ct_infos: &C, key_infos: &K, ) -> usize

where C: GLWEInfos, K: GGLWEInfos, Self: GLWEAutomorphism<BE>,

fn ckks_rotate_into_default<Dst, Src, K>( &self, dst: &mut Dst, src: &Src, key: &K, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAutomorphism<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + GLWEInfos + LWEInfos + CKKSInfos + SetCKKSInfos, Src: GLWEToBackendRef<BE> + GLWEInfos + LWEInfos + CKKSInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

fn ckks_rotate_assign_default<Dst, K>( &self, dst: &mut Dst, key: &K, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEAutomorphism<BE>, Dst: GLWEToBackendMut<BE> + GLWEInfos + LWEInfos + CKKSInfos + SetCKKSInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

impl<BE> CKKSRotateOps<BE> for Module<BE>

where BE: Backend + CKKSRotateImpl<BE>, Module<BE>: GLWEAutomorphism<BE> + GLWEShift<BE>,

fn ckks_rotate_tmp_bytes<C, K>(&self, ct_infos: &C, key_infos: &K) -> usize

where C: CKKSCtBounds, K: GGLWEInfos,

fn ckks_rotate_into<Dst, Src, H, K>( &self, dst: &mut Dst, src: &Src, k: i64, keys: &H, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where K: GLWEAutomorphismKeyPreparedToBackendRef<BE> + GGLWEPreparedToBackendRef<BE> + GetGaloisElement + GGLWEInfos, H: GLWEAutomorphismKeyHelper<K, BE>, Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, Src: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = rotate(src, k): shifts all complex slots by k positions.

fn ckks_rotate_assign<Dst, H, K>( &self, dst: &mut Dst, k: i64, keys: &H, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where K: GLWEAutomorphismKeyPreparedToBackendRef<BE> + GGLWEPreparedToBackendRef<BE> + GetGaloisElement + GGLWEInfos, H: GLWEAutomorphismKeyHelper<K, BE>, Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos,

Computes dst = rotate(dst, k) in-place. Metadata is unchanged.

impl CKKSSubDefault<FFT64Ref> for Module<FFT64Ref>

fn ckks_sub_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshTmpBytes,

fn ckks_sub_pt_vec_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshTmpBytes,

fn ckks_sub_pt_const_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshTmpBytes,

fn ckks_sub_into_default<Dst, A, B>( &self, dst: &mut Dst, a: &A, b: &B, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWESub<BE> + GLWEShift<BE> + GLWENormalize<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + SetCKKSInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, B: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_into_unsafe_default<Dst, A, B>( &self, dst: &mut Dst, a: &A, b: &B, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWESub<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + SetCKKSInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, B: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_assign_default<Dst, A>( &self, dst: &mut Dst, a: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWESub<BE> + GLWEShift<BE> + GLWENormalize<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSInfos,

fn ckks_sub_assign_unsafe_default<Dst, A>( &self, dst: &mut Dst, a: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWESub<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSInfos,

fn ckks_sub_one_assign_default<Dst>( &self, dst: &mut Dst, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE> + GLWENormalize<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + LWEInfos,

fn ckks_sub_pt_vec_into_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubBackend<BE> + GLWEShift<BE> + GLWENormalize<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + LWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_vec_into_unsafe_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubBackend<BE> + GLWEShift<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + LWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_vec_assign_default<Dst, P>( &self, dst: &mut Dst, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubBackend<BE> + GLWENormalize<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_vec_assign_unsafe_default<Dst, P>( &self, dst: &mut Dst, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_const_into_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshSubCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + LWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_const_into_unsafe_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE> + VecZnxRshSubCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + LWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_const_assign_default<Dst, P>( &self, dst: &mut Dst, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE> + GLWENormalize<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_const_assign_unsafe_default<Dst, P>( &self, dst: &mut Dst, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

impl CKKSSubDefault<NTT120Ref> for Module<NTT120Ref>

fn ckks_sub_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshTmpBytes,

fn ckks_sub_pt_vec_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshTmpBytes,

fn ckks_sub_pt_const_tmp_bytes_default(&self) -> usize

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshTmpBytes,

fn ckks_sub_into_default<Dst, A, B>( &self, dst: &mut Dst, a: &A, b: &B, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWESub<BE> + GLWEShift<BE> + GLWENormalize<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + SetCKKSInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, B: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_into_unsafe_default<Dst, A, B>( &self, dst: &mut Dst, a: &A, b: &B, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWESub<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + LWEInfos + SetCKKSInfos + CKKSInfos, A: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos, B: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_assign_default<Dst, A>( &self, dst: &mut Dst, a: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWESub<BE> + GLWEShift<BE> + GLWENormalize<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSInfos,

fn ckks_sub_assign_unsafe_default<Dst, A>( &self, dst: &mut Dst, a: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWESub<BE> + GLWEShift<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSInfos,

fn ckks_sub_one_assign_default<Dst>( &self, dst: &mut Dst, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE> + GLWENormalize<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + LWEInfos,

fn ckks_sub_pt_vec_into_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubBackend<BE> + GLWEShift<BE> + GLWENormalize<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + LWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_vec_into_unsafe_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubBackend<BE> + GLWEShift<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + LWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_vec_assign_default<Dst, P>( &self, dst: &mut Dst, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubBackend<BE> + GLWENormalize<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_vec_assign_unsafe_default<Dst, P>( &self, dst: &mut Dst, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_const_into_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE> + GLWENormalize<BE> + VecZnxRshSubCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + LWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_const_into_unsafe_default<Dst, A, P>( &self, dst: &mut Dst, a: &A, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: GLWEShift<BE> + VecZnxRshSubCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + SetCKKSInfos + LWEInfos, A: GLWEToBackendRef<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_const_assign_default<Dst, P>( &self, dst: &mut Dst, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE> + GLWENormalize<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

fn ckks_sub_pt_const_assign_unsafe_default<Dst, P>( &self, dst: &mut Dst, dst_coeff: usize, cst: &P, const_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Self: VecZnxRshSubCoeffIntoBackend<BE> + CKKSPlaintextDefault<BE>, Dst: GLWEToBackendMut<BE> + CKKSInfos + LWEInfos, P: GLWEToBackendRef<BE> + LWEInfos + CKKSInfos,

impl<BE> CKKSSubOps<BE> for Module<BE>

where BE: Backend + CKKSSubImpl<BE>,

fn ckks_sub_tmp_bytes(&self) -> usize

fn ckks_sub_pt_vec_tmp_bytes(&self) -> usize

fn ckks_sub_into<Dst, A, B>( &self, dst: &mut Dst, a: &A, b: &B, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds, B: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = a - b.

fn ckks_sub_assign<Dst, A>( &self, dst: &mut Dst, a: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst -= a in-place.

fn ckks_sub_one_assign<Dst>( &self, dst: &mut Dst, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos,

Computes dst -= 1 in-place.

fn ckks_sub_pt_vec_into<Dst, A, P>( &self, dst: &mut Dst, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = a - pt where pt is a full plaintext polynomial.

fn ckks_sub_pt_vec_assign<Dst, P>( &self, dst: &mut Dst, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst -= pt in-place.

fn ckks_sub_pt_const_tmp_bytes(&self) -> usize

fn ckks_sub_pt_const_into<Dst, A, P>( &self, dst: &mut Dst, a: &A, dst_coeff: usize, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, A: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst = a - pt[pt_coeff], subtracting one quantized constant from a single coefficient slot of the ciphertext.

fn ckks_sub_pt_const_assign<Dst, P>( &self, dst: &mut Dst, dst_coeff: usize, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: GLWEToBackendMut<BE> + CKKSCtBounds + SetCKKSInfos, P: GLWEToBackendRef<BE> + CKKSCtBounds,

Computes dst -= pt[pt_coeff] in-place.

impl<BE> CKKSSubOpsUnnormalized<BE> for Module<BE>

where BE: Backend + CKKSSubImpl<BE>,

fn ckks_sub_into_unnormalized<Dst, A, B>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, a: &A, b: &B, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE> + CKKSCtBounds, B: GLWEToBackendRef<BE> + CKKSCtBounds,

fn ckks_sub_assign_unnormalized<Dst, A>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, a: &A, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE> + CKKSInfos,

fn ckks_sub_pt_vec_into_unnormalized<Dst, A, P>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, a: &A, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

fn ckks_sub_pt_vec_assign_unnormalized<Dst, P>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, pt: &P, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, P: GLWEToBackendRef<BE> + CKKSCtBounds,

fn ckks_sub_pt_const_into_unnormalized<Dst, A, P>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, a: &A, dst_coeff: usize, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE> + CKKSCtBounds, P: GLWEToBackendRef<BE> + CKKSCtBounds,

fn ckks_sub_pt_const_assign_unnormalized<Dst, P>( &self, dst: &mut CKKSCiphertext<Dst, Unnormalized>, dst_coeff: usize, pt: &P, pt_coeff: usize, scratch: &mut ScratchArena<'_, BE>, ) -> Result<(), Error>

where Dst: Data, CKKSCiphertext<Dst, Unnormalized>: GLWEToBackendMut<BE>, P: GLWEToBackendRef<BE> + CKKSCtBounds,

impl<BE> CnvPVecAlloc<BE> for Module<BE>

where BE: Backend,

fn cnv_pvec_left_alloc( &self, cols: usize, size: usize, ) -> CnvPVecL<<BE as Backend>::OwnedBuf, BE>

fn cnv_pvec_right_alloc( &self, cols: usize, size: usize, ) -> CnvPVecR<<BE as Backend>::OwnedBuf, BE>

impl<BE> CnvPVecBytesOf for Module<BE>

where BE: Backend,

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

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

impl<BE> Convolution<BE> for Module<BE>

where BE: Backend + HalConvolutionImpl<BE>,

fn cnv_prepare_left_tmp_bytes(&self, res_size: usize, a_size: usize) -> usize

Returns scratch bytes required for cnv_prepare_left.

fn cnv_prepare_left( &self, res: &mut CnvPVecL<<BE as Backend>::BufMut<'_>, BE>, a: &VecZnx<<BE as Backend>::BufRef<'_>>, mask: i64, scratch: &mut ScratchArena<'_, BE>, )

Prepares a coefficient-domain VecZnx as the left operand of a bivariate convolution.

fn cnv_prepare_right_tmp_bytes(&self, res_size: usize, a_size: usize) -> usize

Returns scratch bytes required for cnv_prepare_right.

fn cnv_prepare_right( &self, res: &mut CnvPVecR<<BE as Backend>::BufMut<'_>, BE>, a: &VecZnx<<BE as Backend>::BufRef<'_>>, mask: i64, scratch: &mut ScratchArena<'_, BE>, )

Prepares a coefficient-domain VecZnx as the right operand of a bivariate convolution.

fn cnv_apply_dft_tmp_bytes( &self, cnv_offset: usize, res_size: usize, a_size: usize, b_size: usize, ) -> usize

Returns scratch bytes required for cnv_apply_dft.

fn cnv_by_const_apply_tmp_bytes( &self, res_size: usize, cnv_offset: usize, a_size: usize, b_size: usize, ) -> usize

Returns scratch bytes required for cnv_by_const_apply.

fn cnv_by_const_apply( &self, cnv_offset: usize, res: &mut VecZnxBig<<BE as Backend>::BufMut<'_>, BE>, res_col: usize, a: &VecZnx<<BE as Backend>::BufRef<'_>>, a_col: usize, b: &VecZnx<<BE as Backend>::BufRef<'_>>, b_col: usize, b_coeff: usize, scratch: &mut ScratchArena<'_, BE>, )

Evaluates a bivariate convolution over Z[X, Y] (x) Z[Y] mod (X^N + 1) where Y = 2^-K over the selected columns and stores the result on the selected column, scaled by 2^{cnv_offset * Base2K}

fn cnv_apply_dft( &self, cnv_offset: usize, res: &mut VecZnxDft<<BE as Backend>::BufMut<'_>, BE>, res_col: usize, a: &CnvPVecL<<BE as Backend>::BufRef<'_>, BE>, a_col: usize, b: &CnvPVecR<<BE as Backend>::BufRef<'_>, BE>, b_col: usize, scratch: &mut ScratchArena<'_, BE>, )

Evaluates a bivariate convolution over Z[X, Y] (x) Z[X, Y] mod (X^N + 1) where Y = 2^-K over the selected columns and stores the result on the selected column, scaled by 2^{cnv_offset * Base2K}

fn cnv_pairwise_apply_dft_tmp_bytes( &self, cnv_offset: usize, res_size: usize, a_size: usize, b_size: usize, ) -> usize

Returns scratch bytes required for cnv_pairwise_apply_dft.

fn cnv_pairwise_apply_dft( &self, cnv_offset: usize, res: &mut VecZnxDft<<BE as Backend>::BufMut<'_>, BE>, res_col: usize, a: &CnvPVecL<<BE as Backend>::BufRef<'_>, BE>, b: &CnvPVecR<<BE as Backend>::BufRef<'_>, BE>, i: usize, j: usize, scratch: &mut ScratchArena<'_, BE>, )

Evaluates the bivariate pair-wise convolution res = (a[i] + a[j]) * (b[i] + b[j]). If i == j then calls Convolution::cnv_apply_dft, i.e. res = a[i] * b[i]. See Convolution::cnv_apply_dft for information about the bivariate convolution.

fn cnv_prepare_self_tmp_bytes(&self, res_size: usize, a_size: usize) -> usize

Returns scratch bytes required for cnv_prepare_self.

fn cnv_prepare_self( &self, left: &mut CnvPVecL<<BE as Backend>::BufMut<'_>, BE>, right: &mut CnvPVecR<<BE as Backend>::BufMut<'_>, BE>, a: &VecZnx<<BE as Backend>::BufRef<'_>>, mask: i64, scratch: &mut ScratchArena<'_, BE>, )

Prepares both left and right convolution operands from the same input polynomial, sharing the FFT/NTT computation. This is an optimization for self-convolution (squaring) where both operands are the same polynomial.

impl<BE> CyclotomicOrder for Module<BE>

where BE: Backend, Module<BE>: ModuleN,

fn cyclotomic_order(&self) -> i64

Returns 2N, the order of the cyclotomic polynomial X^N + 1.

impl<B> Drop for Module<B>

where B: Backend,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<BE: Backend> FFTModuleHandle<<BE as Backend>::ScalarPrep> for Module<BE>

where BE::ScalarPrep: Float + FloatConst + Debug, BE::Handle: FFTHandleProvider<BE::ScalarPrep>,

fn get_fft_table(&self) -> &ReimFFTTable<BE::ScalarPrep>

fn get_ifft_table(&self) -> &ReimIFFTTable<BE::ScalarPrep>

impl<BE> GGLWECompressedEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn gglwe_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn gglwe_compressed_encrypt_sk<R, P, S, E>( &self, res: &mut R, pt: &P, sk: &S, seed: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWECompressedToBackendMut<BE> + GGLWECompressedSeedMut, P: ScalarZnxToBackendRef<BE>, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>,

impl<B> GGLWEDecompress for Module<B>

where B: Backend, Module<B>: GLWEDecompress,

fn decompress_gglwe<R, O>(&self, res: &mut R, other: &O)

where R: GGLWEToBackendMut<Self::Backend> + GGLWEInfos, O: GGLWECompressedToBackendRef<Self::Backend> + GGLWEInfos,

Decompresses other into res.

impl<BE> GGLWEEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn gglwe_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn gglwe_encrypt_sk<R, P, S, E>( &self, res: &mut R, pt: &P, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE>, P: ScalarZnxToBackendRef<BE>, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>,

impl<BE> GGLWEExternalProduct<BE> for Module<BE>

where BE: Backend + GGLWEExternalProductImpl<BE>, Module<BE>: GLWEExternalProduct<BE>,

fn gglwe_external_product_tmp_bytes<R, A, B>( &self, res_infos: &R, a_infos: &A, b_infos: &B, ) -> usize

where R: GGLWEInfos, A: GGLWEInfos, B: GGSWInfos,

fn gglwe_external_product<R, A, B>( &self, res: &mut R, a: &A, b: &B, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + GGLWEInfos, A: GGLWEToBackendRef<BE> + GGLWEInfos, B: GGSWPreparedToBackendRef<BE> + GGSWInfos,

fn gglwe_external_product_assign<R, A>( &self, res: &mut R, a: &A, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + GGLWEInfos, A: GGSWPreparedToBackendRef<BE> + GGSWInfos,

impl<BE> GGLWEKeyswitch<BE> for Module<BE>

where BE: Backend + GGLWEKeyswitchImpl<BE>,

fn gglwe_keyswitch_tmp_bytes<R, A, K>( &self, res_infos: &R, a_infos: &A, key_infos: &K, ) -> usize

where R: GGLWEInfos, A: GGLWEInfos, K: GGLWEInfos,

fn gglwe_keyswitch<R, A, B>( &self, res: &mut R, a: &A, b: &B, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + GGLWEInfos, A: GGLWEToBackendRef<BE> + GGLWEInfos, B: GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

fn gglwe_keyswitch_assign<R, A>( &self, res: &mut R, a: &A, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + GGLWEInfos, A: GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

impl<BE> GGLWENoise<BE> for Module<BE>

where BE: Backend + HostBackend, Module<BE>: VecZnxAddScalarAssignBackend<BE> + VecZnxSubAssignBackend<BE> + GLWENoise<BE> + GLWEDecrypt<BE> + GLWENormalize<BE> + ModuleN + VecZnxDftBytesOf + VecZnxBigBytesOf + VecZnxBigFromSmallBackend<BE> + VecZnxDftApply<BE> + SvpApplyDftToDftAssign<BE> + VecZnxIdftApplyTmpA<BE> + VecZnxBigAddAssign<BE> + VecZnxBigNormalize<BE> + VecZnxBigNormalizeTmpBytes, <BE as Backend>::BufRef<'a>: for<'a> HostDataRef, <BE as Backend>::BufMut<'a>: for<'a> HostDataMut,

fn gglwe_noise_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn gglwe_noise<R, S>( &self, res: &R, res_row: usize, res_col: usize, pt_want: &ScalarZnx<&[u8]>, sk_prepared: &S, scratch: &mut ScratchArena<'_, BE>, ) -> Stats

where R: GGLWEToBackendRef<BE> + GGLWEInfos, S: GLWESecretPreparedToBackendRef<BE> + GLWEInfos, BE: HostBackend, <BE as Backend>::BufRef<'a>: for<'a> HostDataRef, <BE as Backend>::BufMut<'a>: for<'a> HostDataMut,

impl<BE> GGLWEPreparedFactory<BE> for Module<BE>

where BE: Backend, Module<BE>: GetDegree + VmpPMatAlloc<BE> + VmpPMatBytesOf + VmpPrepare<BE> + VmpPrepareTmpBytes,

fn gglwe_prepared_alloc( &self, base2k: Base2K, k: TorusPrecision, rank_in: Rank, rank_out: Rank, dnum: Dnum, dsize: Dsize, ) -> GGLWEPrepared<<BE as Backend>::OwnedBuf, BE>

Allocates a new GGLWEPrepared with the given parameters.

fn gglwe_prepared_alloc_from_infos<A>( &self, infos: &A, ) -> GGLWEPrepared<<BE as Backend>::OwnedBuf, BE>

where A: GGLWEInfos,

Allocates a new GGLWEPrepared matching the parameters of infos.

fn gglwe_prepared_bytes_of( &self, base2k: Base2K, k: TorusPrecision, rank_in: Rank, rank_out: Rank, dnum: Dnum, dsize: Dsize, ) -> usize

Returns the byte size required to store a GGLWEPrepared with the given parameters.

fn gglwe_prepared_bytes_of_from_infos<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

Returns the byte size required to store a GGLWEPrepared matching infos.

fn gglwe_prepare_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

Returns the scratch-space bytes needed by gglwe_prepare.

fn gglwe_prepare<R, O>( &self, res: &mut R, other: &O, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEPreparedToBackendMut<BE>, O: GGLWEToBackendRef<BE>,

Transforms a standard [GGLWE] into the DFT domain, writing the result into res.

impl<BE> GGLWEToGGSWKeyCompressedEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn gglwe_to_ggsw_key_compressed_encrypt_sk_tmp_bytes<A>( &self, infos: &A, ) -> usize

where A: GGLWEInfos,

fn gglwe_to_ggsw_key_compressed_encrypt_sk<R, S, E>( &self, res: &mut R, sk: &S, seed_xa: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToGGSWKeyCompressedToBackendMut<BE> + GGLWEInfos, E: EncryptionInfos, S: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos,

impl<BE> GGLWEToGGSWKeyEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn gglwe_to_ggsw_key_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn gglwe_to_ggsw_key_encrypt_sk<R, S, E>( &self, res: &mut R, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToGGSWKeyToBackendMut<BE>, E: EncryptionInfos, S: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos,

impl<BE> GGLWEToGGSWKeyPreparedFactory<BE> for Module<BE>

where BE: Backend, Module<BE>: GGLWEPreparedFactory<BE>,

fn gglwe_to_ggsw_key_prepared_alloc_from_infos<A>( &self, infos: &A, ) -> GGLWEToGGSWKeyPrepared<<BE as Backend>::OwnedBuf, BE>

where A: GGLWEInfos,

Allocates a new GGLWEToGGSWKeyPrepared matching the parameters of infos.

fn gglwe_to_ggsw_key_prepared_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, dnum: Dnum, dsize: Dsize, ) -> GGLWEToGGSWKeyPrepared<<BE as Backend>::OwnedBuf, BE>

Allocates a new GGLWEToGGSWKeyPrepared with explicit parameters.

fn bytes_of_gglwe_to_ggsw_from_infos<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

Returns the byte size required to store a GGLWEToGGSWKeyPrepared matching infos.

fn bytes_of_gglwe_to_ggsw( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, dnum: Dnum, dsize: Dsize, ) -> usize

Returns the byte size required to store a GGLWEToGGSWKeyPrepared with explicit parameters.

fn gglwe_to_ggsw_key_prepare_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

Returns the scratch-space bytes needed by gglwe_to_ggsw_key_prepare.

fn gglwe_to_ggsw_key_prepare<R, O>( &self, res: &mut R, other: &O, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToGGSWKeyPreparedToBackendMut<BE>, O: GGLWEToGGSWKeyToBackendRef<BE>,

Transforms a standard [GGLWEToGGSWKey] into the DFT domain, writing into res.

impl<BE> GGSWAutomorphism<BE> for Module<BE>

where BE: Backend + AutomorphismImpl<BE> + ConversionImpl<BE>, Module<BE>: ConversionDefault<BE>,

fn ggsw_automorphism_tmp_bytes<R, A, K, T>( &self, res_infos: &R, a_infos: &A, key_infos: &K, tsk_infos: &T, ) -> usize

where R: GGSWInfos, A: GGSWInfos, K: GGLWEInfos, T: GGLWEInfos,

fn ggsw_automorphism<R, A, K, T>( &self, res: &mut R, a: &A, key: &K, key_size: usize, tsk: &T, tsk_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGSWToBackendMut<BE> + GGSWInfos, A: GGSWToBackendRef<BE> + GGSWInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos, T: GGLWEToGGSWKeyPreparedToBackendRef<BE> + GGLWEInfos,

fn ggsw_automorphism_assign<R, K, T>( &self, res: &mut R, key: &K, key_size: usize, tsk: &T, tsk_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGSWToBackendMut<BE> + GGSWInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos, T: GGLWEToGGSWKeyPreparedToBackendRef<BE> + GGLWEInfos,

impl<BE> GGSWCompressedEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn ggsw_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGSWInfos,

fn ggsw_compressed_encrypt_sk<R, P, S, E>( &self, res: &mut R, pt: &P, sk: &S, seed_xa: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGSWCompressedToBackendMut<BE> + GGSWCompressedSeedMut + GGSWInfos, P: ScalarZnxToBackendRef<BE>, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>,

impl<B> GGSWDecompress for Module<B>

where B: Backend, Module<B>: GLWEDecompress,

fn decompress_ggsw<R, O>(&self, res: &mut R, other: &O)

where R: GGSWToBackendMut<Self::Backend> + GGSWInfos, O: GGSWCompressedToBackendRef<Self::Backend> + GGSWInfos,

Decompresses other into res.

impl<BE> GGSWEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn ggsw_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGSWInfos,

fn ggsw_encrypt_sk<R, P, S, E>( &self, res: &mut R, pt: &P, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGSWToBackendMut<BE> + GGSWInfos + GGSWAtViewMut<BE>, P: ScalarZnxToBackendRef<BE> + ZnxInfos, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE> + LWEInfos + GLWEInfos,

impl<BE> GGSWExpandRows<BE> for Module<BE>

where BE: Backend + ConversionImpl<BE>, Module<BE>: ConversionDefault<BE>,

fn ggsw_expand_rows_tmp_bytes<R, A>( &self, res_infos: &R, tsk_infos: &A, ) -> usize

where R: GGSWInfos, A: GGLWEInfos,

fn ggsw_expand_row<R, T>( &self, res: &mut R, tsk: &T, tsk_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGSWToBackendMut<BE> + GGSWInfos, T: GGLWEToGGSWKeyPreparedToBackendRef<BE> + GGLWEInfos,

impl<BE> GGSWExternalProduct<BE> for Module<BE>

where BE: Backend + GGSWExternalProductImpl<BE>, Module<BE>: GLWEExternalProduct<BE>,

fn ggsw_external_product_tmp_bytes<R, A, B>( &self, res_infos: &R, a_infos: &A, b_infos: &B, ) -> usize

where R: GGSWInfos, A: GGSWInfos, B: GGSWInfos,

fn ggsw_external_product<R, A, B>( &self, res: &mut R, a: &A, b: &B, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGSWToBackendMut<BE> + GGSWAtViewMut<BE> + GGSWInfos, A: GGSWToBackendRef<BE> + GGSWAtViewRef<BE> + GGSWInfos, B: GGSWPreparedToBackendRef<BE> + GGSWInfos,

fn ggsw_external_product_assign<R, A>( &self, res: &mut R, a: &A, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGSWToBackendMut<BE> + GGSWAtViewMut<BE> + GGSWInfos, A: GGSWPreparedToBackendRef<BE> + GGSWInfos,

impl<BE> GGSWFromGGLWE<BE> for Module<BE>

where BE: Backend + ConversionImpl<BE>, Module<BE>: ConversionDefault<BE>,

fn ggsw_from_gglwe_tmp_bytes<R, A>(&self, res_infos: &R, tsk_infos: &A) -> usize

where R: GGSWInfos, A: GGLWEInfos,

fn ggsw_from_gglwe<R, A, T>( &self, res: &mut R, a: &A, tsk: &T, tsk_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGSWToBackendMut<BE> + GGSWInfos, A: GGLWEToBackendRef<BE> + GGLWEInfos, T: GGLWEToGGSWKeyPreparedToBackendRef<BE> + GGLWEInfos,

impl<BE> GGSWKeyswitch<BE> for Module<BE>

where BE: Backend + GGSWKeyswitchImpl<BE>,

fn ggsw_keyswitch_tmp_bytes<R, A, K, T>( &self, res_infos: &R, a_infos: &A, key_infos: &K, tsk_infos: &T, ) -> usize

where R: GGSWInfos, A: GGSWInfos, K: GGLWEInfos, T: GGLWEInfos,

fn ggsw_keyswitch<R, A, K, T>( &self, res: &mut R, a: &A, key: &K, key_size: usize, tsk: &T, tsk_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGSWToBackendMut<BE> + GGSWInfos, A: GGSWToBackendRef<BE> + GGSWInfos, K: GGLWEPreparedToBackendRef<BE> + GGLWEInfos, T: GGLWEToGGSWKeyPreparedToBackendRef<BE> + GGLWEInfos,

fn ggsw_keyswitch_assign<R, K, T>( &self, res: &mut R, key: &K, key_size: usize, tsk: &T, tsk_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGSWToBackendMut<BE> + GGSWInfos, K: GGLWEPreparedToBackendRef<BE> + GGLWEInfos, T: GGLWEToGGSWKeyPreparedToBackendRef<BE> + GGLWEInfos,

impl<BE> GGSWNoise<BE> for Module<BE>

where BE: Backend + HostBackend, Module<BE>: VecZnxAddScalarAssignBackend<BE> + VecZnxDftApply<BE> + SvpApplyDftToDftAssign<BE> + VecZnxIdftApplyTmpA<BE> + VecZnxBigBytesOf + VecZnxDftBytesOf + VecZnxBigFromSmallBackend<BE> + VecZnxBigAddAssign<BE> + VecZnxBigNormalize<BE> + VecZnxBigNormalizeTmpBytes + VecZnxSubAssignBackend<BE> + GLWENoise<BE> + GLWEDecrypt<BE> + GLWENormalize<BE>, <BE as Backend>::BufRef<'a>: for<'a> HostDataRef, <BE as Backend>::BufMut<'a>: for<'a> HostDataMut,

fn ggsw_noise_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGSWInfos,

fn ggsw_noise<R, S>( &self, res: &R, res_row: usize, res_col: usize, pt_want: &ScalarZnx<&[u8]>, sk_prepared: &S, scratch: &mut ScratchArena<'_, BE>, ) -> Stats

where R: GGSWToBackendRef<BE> + GGSWInfos, S: GLWESecretPreparedToBackendRef<BE>, BE: HostBackend, <BE as Backend>::BufRef<'a>: for<'a> HostDataRef, <BE as Backend>::BufMut<'a>: for<'a> HostDataMut,

impl<B> GGSWPreparedFactory<B> for Module<B>

where B: Backend, Module<B>: GetDegree + VmpPMatAlloc<B> + VmpPMatBytesOf + VmpPrepareTmpBytes + VmpPrepare<B> + VmpZero<B>,

fn ggsw_prepared_alloc( &self, base2k: Base2K, k: TorusPrecision, dnum: Dnum, dsize: Dsize, rank: Rank, ) -> GGSWPrepared<<B as Backend>::OwnedBuf, B>

Allocates a new prepared GGSW with the given parameters.

fn ggsw_prepared_alloc_from_infos<A>( &self, infos: &A, ) -> GGSWPrepared<<B as Backend>::OwnedBuf, B>

where A: GGSWInfos,

fn ggsw_prepared_bytes_of( &self, base2k: Base2K, k: TorusPrecision, dnum: Dnum, dsize: Dsize, rank: Rank, ) -> usize

fn ggsw_prepared_bytes_of_from_infos<A>(&self, infos: &A) -> usize

where A: GGSWInfos,

fn ggsw_prepare_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGSWInfos,

fn ggsw_prepare<R, O>( &self, res: &mut R, other: &O, scratch: &mut ScratchArena<'_, B>, )

where R: GGSWPreparedToBackendMut<B>, O: GGSWToBackendRef<B>,

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

where R: GGSWPreparedToBackendMut<B>,

impl<BE> GGSWRotate<BE> for Module<BE>

where BE: Backend + GGSWRotateImpl<BE>, Module<BE>: GGSWRotateDefault<BE>,

fn ggsw_rotate_tmp_bytes(&self) -> usize

fn ggsw_rotate<R, A>(&self, k: i64, res: &mut R, a: &A)

where R: GGSWToBackendMut<BE> + GGSWAtViewMut<BE> + GGSWInfos, A: GGSWToBackendRef<BE> + GGSWAtViewRef<BE> + GGSWInfos,

fn ggsw_rotate_assign<R>( &self, k: i64, res: &mut R, scratch: &mut ScratchArena<'_, BE>, )

where R: GGSWToBackendMut<BE> + GGSWInfos,

impl<BE> GLWEAdd<BE> for Module<BE>

where BE: Backend + GLWEAddImpl<BE>, Module<BE>: GLWEAddDefault<BE>,

fn glwe_add_into<R, A, B>(&self, res: &mut R, a: &A, b: &B)

where R: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE>, B: GLWEToBackendRef<BE>,

fn glwe_add_assign<R, A>(&self, res: &mut R, a: &A)

where R: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE>,

impl<BE> GLWEAutomorphism<BE> for Module<BE>

where BE: Backend + AutomorphismImpl<BE>,

fn glwe_automorphism_tmp_bytes<R, A, K>( &self, res_infos: &R, a_infos: &A, key_infos: &K, ) -> usize

where R: GLWEInfos, A: GLWEInfos, K: GGLWEInfos,

fn glwe_automorphism<R, A, K>( &self, res: &mut R, a: &A, key: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

fn glwe_automorphism_assign<R, K>( &self, res: &mut R, key: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

fn glwe_automorphism_add<R, A, K>( &self, res: &mut R, a: &A, key: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

fn glwe_automorphism_add_assign<R, K>( &self, res: &mut R, key: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

fn glwe_automorphism_sub<R, A, K>( &self, res: &mut R, a: &A, key: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

fn glwe_automorphism_sub_negate<R, A, K>( &self, res: &mut R, a: &A, key: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

fn glwe_automorphism_sub_assign<R, K>( &self, res: &mut R, key: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

fn glwe_automorphism_sub_negate_assign<R, K>( &self, res: &mut R, key: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, K: GetGaloisElement + GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

impl<BE> GLWEAutomorphismKeyAutomorphism<BE> for Module<BE>

where BE: Backend + AutomorphismImpl<BE>,

fn glwe_automorphism_key_automorphism_tmp_bytes<R, A, K>( &self, res_infos: &R, a_infos: &A, key_infos: &K, ) -> usize

where R: GGLWEInfos, A: GGLWEInfos, K: GGLWEInfos,

fn glwe_automorphism_key_automorphism<R, A, K>( &self, res: &mut R, a: &A, key: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + SetGaloisElement + GGLWEInfos, A: GGLWEToBackendRef<BE> + GetGaloisElement + GGLWEInfos, K: GGLWEPreparedToBackendRef<BE> + GetGaloisElement + GGLWEInfos,

fn glwe_automorphism_key_automorphism_assign<R, K>( &self, res: &mut R, key: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + SetGaloisElement + GetGaloisElement + GGLWEInfos, K: GGLWEPreparedToBackendRef<BE> + GetGaloisElement + GGLWEInfos,

impl<BE> GLWEAutomorphismKeyCompressedEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn glwe_automorphism_key_compressed_encrypt_sk_tmp_bytes<A>( &self, infos: &A, ) -> usize

where A: GGLWEInfos,

fn glwe_automorphism_key_compressed_encrypt_sk<R, S, E>( &self, res: &mut R, p: i64, sk: &S, seed_xa: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWECompressedToBackendMut<BE> + GGLWECompressedSeedMut + SetGaloisElement + GGLWEInfos, E: EncryptionInfos, S: GLWESecretToBackendRef<BE> + GLWEInfos,

impl<B> GLWEAutomorphismKeyDecompress for Module<B>

where B: Backend, Module<B>: GLWEDecompress,

fn decompress_automorphism_key<R, O>(&self, res: &mut R, other: &O)

where R: GGLWEToBackendMut<Self::Backend> + GGLWEInfos + SetGaloisElement, O: GGLWECompressedToBackendRef<Self::Backend> + GGLWEInfos + GetGaloisElement,

impl<BE> GLWEAutomorphismKeyEncryptPk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn glwe_automorphism_key_encrypt_pk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

impl<BE> GLWEAutomorphismKeyEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn glwe_automorphism_key_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn glwe_automorphism_key_encrypt_sk<R, S, E>( &self, res: &mut R, p: i64, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + SetGaloisElement + GGLWEInfos, E: EncryptionInfos, S: GLWESecretToBackendRef<BE> + GLWEInfos,

impl<B> GLWEAutomorphismKeyPreparedFactory<B> for Module<B>

where B: Backend, Module<B>: GGLWEPreparedFactory<B>,

fn glwe_automorphism_key_prepared_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, dnum: Dnum, dsize: Dsize, ) -> GLWEAutomorphismKeyPrepared<<B as Backend>::OwnedBuf, B>

fn glwe_automorphism_key_prepared_alloc_from_infos<A>( &self, infos: &A, ) -> GLWEAutomorphismKeyPrepared<<B as Backend>::OwnedBuf, B>

where A: GGLWEInfos,

fn glwe_automorphism_key_prepared_bytes_of( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, dnum: Dnum, dsize: Dsize, ) -> usize

fn glwe_automorphism_key_prepared_bytes_of_from_infos<A>( &self, infos: &A, ) -> usize

where A: GGLWEInfos,

fn glwe_automorphism_key_prepare_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn glwe_automorphism_key_prepare<R, O>( &self, res: &mut R, other: &O, scratch: &mut ScratchArena<'_, B>, )

where R: GGLWEPreparedToBackendMut<B> + SetGaloisElement, O: GGLWEToBackendRef<B> + GetGaloisElement,

impl<BE> GLWECompressedEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn glwe_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GLWEInfos,

fn glwe_compressed_encrypt_sk<R, P, S, E>( &self, res: &mut R, pt: &P, sk: &S, seed_xa: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWECompressedToBackendMut<BE> + GLWECompressedSeedMut, P: GLWEToBackendRef<BE>, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>,

impl<BE> GLWECopy<BE> for Module<BE>

where BE: Backend + GLWECopyImpl<BE>, Module<BE>: GLWECopyDefault<BE>,

fn glwe_copy<R, A>(&self, res: &mut R, a: &A)

where R: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE>,

impl<B> GLWEDecompress for Module<B>

where B: Backend, Module<B>: GetDegree + VecZnxFillUniformSourceBackend<B> + VecZnxCopyBackend<B>,

type Backend = B

fn decompress_glwe<R, O>(&self, res: &mut R, other: &O)

where R: GLWEToBackendMut<Self::Backend> + SetLWEInfos, O: GLWECompressedToBackendRef<Self::Backend> + GLWEInfos,

Decompresses other into res by copying the body and regenerating the mask.

impl<BE> GLWEDecrypt<BE> for Module<BE>

where BE: Backend + HostBackend + DecryptionImpl<BE>,

fn glwe_decrypt_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GLWEInfos,

fn glwe_decrypt<R, P, S>( &self, res: &R, pt: &mut P, sk: &S, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendRef<BE> + GLWEInfos, P: GLWEToBackendMut<BE> + GLWEInfos + SetLWEInfos, S: GLWESecretPreparedToBackendRef<BE> + GLWEInfos,

impl<BE> GLWEEncryptPk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn glwe_encrypt_pk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GLWEInfos,

fn glwe_encrypt_pk<R, P, K, E>( &self, res: &mut R, pt: &P, pk: &K, enc_infos: &E, source_xu: &mut Source, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, P: GLWEToBackendRef<BE> + GLWEInfos, E: EncryptionInfos, K: GLWEPreparedToBackendRef<BE> + GetDistribution + GLWEInfos,

fn glwe_encrypt_zero_pk<R, K, E>( &self, res: &mut R, pk: &K, enc_infos: &E, source_xu: &mut Source, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, E: EncryptionInfos, K: GLWEPreparedToBackendRef<BE> + GetDistribution + GLWEInfos,

impl<BE> GLWEEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn glwe_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GLWEInfos,

fn glwe_encrypt_sk<R, P, S, E>( &self, res: &mut R, pt: &P, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE>, P: GLWEToBackendRef<BE>, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>,

fn glwe_encrypt_zero_sk<R, E, S>( &self, res: &mut R, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE>, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE>,

impl<BE> GLWEExpandLWE<BE> for Module<BE>

where BE: Backend + ConversionImpl<BE>, Module<BE>: ConversionDefault<BE>,

fn glwe_expand_lwe_tmp_bytes<R, A>(&self, lwe_infos: &R, a_infos: &A) -> usize

where R: LWEInfos, A: GLWEInfos,

fn glwe_expand_lwe<R, A>( &self, res: &mut [R], a: &A, scratch: &mut ScratchArena<'_, BE>, )

where R: LWEToBackendMut<BE> + LWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos,

impl<BE> GLWEExternalProduct<BE> for Module<BE>

where BE: Backend + GLWEExternalProductImpl<BE>,

fn glwe_external_product_tmp_bytes<R, A, B>( &self, res_infos: &R, a_infos: &A, b_infos: &B, ) -> usize

where R: GLWEInfos, A: GLWEInfos, B: GGSWInfos,

fn glwe_external_product_assign<R, D>( &self, res: &mut R, rhs: &D, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, D: GGSWPreparedToBackendRef<BE> + GGSWInfos,

fn glwe_external_product<R, A, D>( &self, res: &mut R, lhs: &A, rhs: &D, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos, D: GGSWPreparedToBackendRef<BE> + GGSWInfos,

impl<BE> GLWEExternalProductInternal<BE> for Module<BE>

where BE: Backend, Module<BE>: ModuleN + VecZnxDftBytesOf + VmpApplyDftToDftTmpBytes + VecZnxNormalizeTmpBytes + VecZnxDftApply<BE> + VmpApplyDftToDft<BE> + VecZnxDftAddAssign<BE> + VecZnxBigBytesOf + VecZnxIdftApply<BE> + VecZnxIdftApplyTmpBytes + VecZnxBigNormalize<BE> + VecZnxNormalize<BE> + VecZnxDftZero<BE>,

fn glwe_external_product_internal_tmp_bytes<R, A, B>( &self, _res_infos: &R, a_infos: &A, b_infos: &B, ) -> usize

where R: GLWEInfos, A: GLWEInfos, B: GGSWInfos,

fn glwe_external_product_dft<'r, A, G>( &self, res_dft: &mut VecZnxDft<<BE as Backend>::BufMut<'r>, BE>, a: &A, ggsw: &G, _key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where A: GLWEToBackendRef<BE>, G: GGSWPreparedToBackendRef<BE>,

impl<BE> GLWEFromLWE<BE> for Module<BE>

where BE: Backend + ConversionImpl<BE>, Module<BE>: ConversionDefault<BE>,

fn glwe_from_lwe_tmp_bytes<R, A, K>( &self, glwe_infos: &R, lwe_infos: &A, key_infos: &K, ) -> usize

where R: GLWEInfos, A: LWEInfos, K: GGLWEInfos,

fn glwe_from_lwe<R, A, K>( &self, res: &mut R, lwe: &A, ksk: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: LWEToBackendRef<BE> + LWEInfos, K: GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

impl<BE> GLWEKeyswitch<BE> for Module<BE>

where BE: Backend + GLWEKeyswitchImpl<BE>,

fn glwe_keyswitch_tmp_bytes<R, A, B>( &self, res_infos: &R, a_infos: &A, key_infos: &B, ) -> usize

where R: GLWEInfos, A: GLWEInfos, B: GGLWEInfos,

fn glwe_keyswitch<R, A, K>( &self, res: &mut R, a: &A, key: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos, K: GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

fn glwe_keyswitch_assign<R, K>( &self, res: &mut R, key: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, K: GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

impl<BE> GLWEMulConst<BE> for Module<BE>

where BE: Backend + GLWEMulConstImpl<BE>, Module<BE>: GLWEMulConstDefault<BE>,

fn glwe_mul_const_tmp_bytes<R, A, B>(&self, res: &R, a: &A, b: &B) -> usize

where R: GLWEInfos, A: GLWEInfos, B: GLWEInfos,

fn glwe_mul_const<R, A, B>( &self, cnv_offset: usize, res: &mut R, a: &A, b: &B, b_coeff: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos, B: GLWEToBackendRef<BE> + GLWEInfos,

fn glwe_mul_const_assign<R, B>( &self, cnv_offset: usize, res: &mut R, b: &B, b_coeff: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, B: GLWEToBackendRef<BE> + GLWEInfos,

impl<BE> GLWEMulPlain<BE> for Module<BE>

where BE: Backend + GLWEMulPlainImpl<BE>, Module<BE>: GLWEMulPlainDefault<BE>,

fn glwe_mul_plain_tmp_bytes<R, A, B>(&self, res: &R, a: &A, b: &B) -> usize

where R: GLWEInfos, A: GLWEInfos, B: GLWEInfos,

fn glwe_mul_plain<R, A, B>( &self, cnv_offset: usize, res: &mut R, a: &A, a_effective_k: usize, b: &B, b_effective_k: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos, B: GLWEToBackendRef<BE> + GLWEInfos,

fn glwe_mul_plain_assign<R, A>( &self, cnv_offset: usize, res: &mut R, res_effective_k: usize, a: &A, a_effective_k: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos,

impl<BE> GLWEMulXpMinusOne<BE> for Module<BE>

where BE: Backend + GLWEMulXpMinusOneImpl<BE>, Module<BE>: GLWEMulXpMinusOneDefault<BE>,

fn glwe_mul_xp_minus_one<R, A>(&self, k: i64, res: &mut R, a: &A)

where R: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE>,

fn glwe_mul_xp_minus_one_assign<R>( &self, k: i64, res: &mut R, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE>,

impl<BE> GLWENegate<BE> for Module<BE>

where BE: Backend + GLWENegateImpl<BE>, Module<BE>: GLWENegateDefault<BE>,

fn glwe_negate<R, A>(&self, res: &mut R, a: &A)

where R: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE>,

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

where R: GLWEToBackendMut<BE>,

impl<BE> GLWENoise<BE> for Module<BE>

where BE: Backend + HostBackend, Module<BE>: GLWEDecrypt<BE> + GLWENormalize<BE> + VecZnxSubAssignBackend<BE> + ModuleN + VecZnxDftBytesOf + VecZnxBigBytesOf + VecZnxBigFromSmallBackend<BE> + VecZnxDftApply<BE> + SvpApplyDftToDftAssign<BE> + VecZnxIdftApplyTmpA<BE> + VecZnxBigAddAssign<BE> + VecZnxBigNormalize<BE> + VecZnxBigNormalizeTmpBytes, <BE as Backend>::BufMut<'a>: for<'a> HostDataMut,

fn glwe_noise_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GLWEInfos,

fn glwe_noise<R, P, S>( &self, res: &R, pt_want: &P, sk_prepared: &S, scratch: &mut ScratchArena<'_, BE>, ) -> Stats

where R: GLWEToBackendRef<BE> + GLWEInfos, P: GLWEToBackendRef<BE>, S: GLWESecretPreparedToBackendRef<BE> + GLWEInfos, BE: HostBackend, <BE as Backend>::BufMut<'a>: for<'a> HostDataMut,

impl<BE> GLWENormalize<BE> for Module<BE>

where BE: Backend + GLWENormalizeImpl<BE>, Module<BE>: GLWENormalizeDefault<BE>,

fn glwe_normalize_tmp_bytes(&self) -> usize

fn glwe_normalize<R, A>( &self, res: &mut R, a: &A, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE>,

fn glwe_normalize_assign<R>( &self, res: &mut R, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE>,

impl<BE> GLWEPacking<BE> for Module<BE>

where BE: Backend + GLWEPackImpl<BE>, Module<BE>: GLWEPackingDefault<BE>,

fn glwe_pack_galois_elements(&self) -> Vec<i64>

fn glwe_pack_tmp_bytes<R, K>(&self, res: &R, key: &K) -> usize

where R: GLWEInfos, K: GGLWEInfos,

fn glwe_pack<R, A, K, H>( &self, res: &mut R, a: HashMap<usize, &mut A>, log_gap_out: usize, keys: &H, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendMut<BE> + GLWEInfos, K: GGLWEPreparedToBackendRef<BE> + GetGaloisElement + GGLWEInfos, H: GLWEAutomorphismKeyHelper<K, BE>,

impl<B> GLWEPreparedFactory<B> for Module<B>

where B: Backend, Module<B>: VecZnxDftAlloc<B> + VecZnxDftBytesOf + VecZnxDftApply<B>,

fn glwe_prepared_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, ) -> GLWEPrepared<<B as Backend>::OwnedBuf, B>

Allocates a new prepared GLWE with the given parameters.

fn glwe_prepared_alloc_from_infos<A>( &self, infos: &A, ) -> GLWEPrepared<<B as Backend>::OwnedBuf, B>

where A: GLWEInfos,

fn glwe_prepared_bytes_of( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, ) -> usize

fn glwe_prepared_bytes_of_from_infos<A>(&self, infos: &A) -> usize

where A: GLWEInfos,

fn glwe_prepare<R, O>(&self, res: &mut R, other: &O)

where R: GLWEPreparedToBackendMut<B>, O: GLWEToBackendRef<B> + GLWEInfos,

impl<BE> GLWEPublicKeyGenerate<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn glwe_public_key_generate<R, S, E>( &self, res: &mut R, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, )

where R: GLWEToBackendMut<BE> + GetDistributionMut + GLWEInfos, E: EncryptionInfos, S: GLWESecretPreparedToBackendRef<BE> + GetDistribution,

impl<B> GLWEPublicKeyPreparedFactory<B> for Module<B>

where B: Backend, Module<B>: VecZnxDftAlloc<B> + VecZnxDftBytesOf + VecZnxDftApply<B>,

fn glwe_public_key_prepared_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, ) -> GLWEPublicKeyPrepared<<B as Backend>::OwnedBuf, B>

fn glwe_public_key_prepared_alloc_from_infos<A>( &self, infos: &A, ) -> GLWEPublicKeyPrepared<<B as Backend>::OwnedBuf, B>

where A: GLWEInfos,

fn glwe_public_key_prepared_bytes_of( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, ) -> usize

fn glwe_public_key_prepared_bytes_of_from_infos<A>(&self, infos: &A) -> usize

where A: GLWEInfos,

fn glwe_public_key_prepare<R, O>(&self, res: &mut R, other: &O)

where R: GLWEPreparedToBackendMut<B> + GetDistributionMut, O: GLWEToBackendRef<B> + GetDistribution + GLWEInfos,

impl<BE> GLWERotate<BE> for Module<BE>

where BE: Backend + GLWERotateImpl<BE>, Module<BE>: GLWERotateDefault<BE>,

fn glwe_rotate_tmp_bytes(&self) -> usize

fn glwe_rotate<R, A>(&self, k: i64, res: &mut R, a: &A)

where R: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE>,

fn glwe_rotate_assign<R>( &self, k: i64, res: &mut R, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE>,

impl<B> GLWESecretPreparedFactory<B> for Module<B>

where B: Backend, Module<B>: GetDegree + SvpPPolBytesOf + SvpPPolAlloc<B> + SvpPrepare<B>,

fn glwe_secret_prepared_alloc( &self, rank: Rank, ) -> GLWESecretPrepared<<B as Backend>::OwnedBuf, B>

fn glwe_secret_prepared_alloc_from_infos<A>( &self, infos: &A, ) -> GLWESecretPrepared<<B as Backend>::OwnedBuf, B>

where A: GLWEInfos,

fn glwe_secret_prepared_bytes_of(&self, rank: Rank) -> usize

fn glwe_secret_prepared_bytes_of_from_infos<A>(&self, infos: &A) -> usize

where A: GLWEInfos,

fn glwe_secret_prepare<R, O>(&self, res: &mut R, other: &O)

where R: GLWESecretPreparedToBackendMut<B> + GetDistributionMut, O: GLWESecretToBackendRef<B> + GetDistribution,

impl<BE> GLWESecretTensorFactory<BE> for Module<BE>

where BE: Backend, Module<BE>: ModuleN + GLWESecretPreparedFactory<BE> + VecZnxBigNormalize<BE> + VecZnxDftApply<BE> + SvpApplyDftToDft<BE> + VecZnxIdftApplyTmpA<BE> + VecZnxDftBytesOf + VecZnxBigBytesOf + VecZnxBigNormalizeTmpBytes,

fn glwe_secret_tensor_prepare_tmp_bytes(&self, rank: Rank) -> usize

fn glwe_secret_tensor_prepare<R, A>( &self, res: &mut R, a: &A, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWESecretToBackendMut<BE> + GetDistributionMut + GLWEInfos, A: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos,

impl<B> GLWESecretTensorPreparedFactory<B> for Module<B>

where B: Backend, Module<B>: GLWESecretPreparedFactory<B>,

fn glwe_secret_tensor_prepared_alloc( &self, rank: Rank, ) -> GLWESecretTensorPrepared<<B as Backend>::OwnedBuf, B>

fn glwe_secret_tensor_prepared_alloc_from_infos<A>( &self, infos: &A, ) -> GLWESecretTensorPrepared<<B as Backend>::OwnedBuf, B>

where A: GLWEInfos,

fn glwe_secret_tensor_prepared_bytes_of(&self, rank: Rank) -> usize

fn glwe_secret_tensor_prepared_bytes_of_from_infos<A>(&self, infos: &A) -> usize

where A: GLWEInfos,

fn glwe_secret_tensor_prepared_prepare<R, O>(&self, res: &mut R, other: &O)

where R: GLWESecretPreparedToBackendMut<B> + GetDistributionMut, O: GLWESecretToBackendRef<B> + GetDistribution,

impl<BE> GLWEShift<BE> for Module<BE>

where BE: Backend + GLWEShiftImpl<BE>, Module<BE>: GLWEShiftDefault<BE>,

fn glwe_shift_tmp_bytes(&self) -> usize

fn glwe_rsh<R>(&self, k: usize, res: &mut R, scratch: &mut ScratchArena<'_, BE>)

where R: GLWEToBackendMut<BE>,

fn glwe_lsh_assign<R>( &self, res: &mut R, k: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE>,

fn glwe_lsh<R, A>( &self, res: &mut R, a: &A, k: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE>,

fn glwe_lsh_add<R, A>( &self, res: &mut R, a: &A, k: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE>,

fn glwe_lsh_sub<R, A>( &self, res: &mut R, a: &A, k: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE>,

impl<BE> GLWESub<BE> for Module<BE>

where BE: Backend + GLWESubImpl<BE>, Module<BE>: GLWESubDefault<BE>,

fn glwe_sub<R, A, B>(&self, res: &mut R, a: &A, b: &B)

where R: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE>, B: GLWEToBackendRef<BE>,

fn glwe_sub_assign<R, A>(&self, res: &mut R, a: &A)

where R: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE>,

fn glwe_sub_negate_assign<R, A>(&self, res: &mut R, a: &A)

where R: GLWEToBackendMut<BE>, A: GLWEToBackendRef<BE>,

impl<BE> GLWESwitchingKeyCompressedEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn glwe_switching_key_compressed_encrypt_sk_tmp_bytes<A>( &self, infos: &A, ) -> usize

where A: GGLWEInfos,

fn glwe_switching_key_compressed_encrypt_sk<R, S1, S2, E>( &self, res: &mut R, sk_in: &S1, sk_out: &S2, seed_xa: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWECompressedToBackendMut<BE> + GGLWECompressedSeedMut + GLWESwitchingKeyDegreesMut + GGLWEInfos, E: EncryptionInfos, S1: GLWESecretToBackendRef<BE> + GLWEInfos, S2: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos,

impl<B> GLWESwitchingKeyDecompress for Module<B>

where B: Backend, Module<B>: GGLWEDecompress,

fn decompress_glwe_switching_key<R, O>(&self, res: &mut R, other: &O)

where R: GGLWEToBackendMut<Self::Backend> + GGLWEInfos + GLWESwitchingKeyDegreesMut, O: GGLWECompressedToBackendRef<Self::Backend> + GGLWEInfos + GLWESwitchingKeyDegrees,

Decompresses other into res, copying degree metadata.

impl<BE> GLWESwitchingKeyEncryptPk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn glwe_switching_key_encrypt_pk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

impl<BE> GLWESwitchingKeyEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn glwe_switching_key_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn glwe_switching_key_encrypt_sk<R, S1, S2, E>( &self, res: &mut R, sk_in: &S1, sk_out: &S2, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + GLWESwitchingKeyDegreesMut + GGLWEInfos, E: EncryptionInfos, S1: GLWESecretToBackendRef<BE> + GLWEInfos, S2: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos,

impl<B> GLWESwitchingKeyPreparedFactory<B> for Module<B>

where B: Backend, Module<B>: GGLWEPreparedFactory<B>,

fn glwe_switching_key_prepared_alloc( &self, base2k: Base2K, k: TorusPrecision, rank_in: Rank, rank_out: Rank, dnum: Dnum, dsize: Dsize, ) -> GLWESwitchingKeyPrepared<<B as Backend>::OwnedBuf, B>

fn glwe_switching_key_prepared_alloc_from_infos<A>( &self, infos: &A, ) -> GLWESwitchingKeyPrepared<<B as Backend>::OwnedBuf, B>

where A: GGLWEInfos,

fn bytes_of_glwe_key_prepared( &self, base2k: Base2K, k: TorusPrecision, rank_in: Rank, rank_out: Rank, dnum: Dnum, dsize: Dsize, ) -> usize

fn glwe_switching_key_prepared_bytes_of_from_infos<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn glwe_switching_key_prepare_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn glwe_switching_key_prepare<R, O>( &self, res: &mut R, other: &O, scratch: &mut ScratchArena<'_, B>, )

where R: GGLWEPreparedToBackendMut<B> + GLWESwitchingKeyDegreesMut, O: GGLWEToBackendRef<B> + GLWESwitchingKeyDegrees,

impl<BE> GLWETensorDecrypt<BE> for Module<BE>

where BE: Backend + HostBackend + DecryptionImpl<BE>,

fn glwe_tensor_decrypt_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GLWEInfos,

fn glwe_tensor_decrypt<R, P, S0, S1>( &self, res: &GLWETensor<R>, pt: &mut GLWEPlaintext<P>, sk: &GLWESecretPrepared<S0, BE>, sk_tensor: &GLWESecretTensorPrepared<S1, BE>, scratch: &mut ScratchArena<'_, BE>, )

where R: Data, P: Data, S0: Data, S1: Data, GLWETensor<R>: GLWEToBackendRef<BE> + GLWEInfos, GLWEPlaintext<P>: GLWEToBackendMut<BE> + GLWEInfos + SetLWEInfos, GLWESecretPrepared<S0, BE>: GLWESecretPreparedToBackendRef<BE> + GLWEInfos, GLWESecretTensorPrepared<S1, BE>: GLWESecretTensorPreparedToBackendRef<BE> + GLWEInfos,

impl<BE> GLWETensorKeyCompressedEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn glwe_tensor_key_compressed_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn glwe_tensor_key_compressed_encrypt_sk<R, S, E>( &self, res: &mut R, sk: &S, seed_xa: [u8; 32], enc_infos: &E, source_xe: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWECompressedToBackendMut<BE> + GGLWEInfos + GGLWECompressedSeedMut, E: EncryptionInfos, S: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos,

impl<B> GLWETensorKeyDecompress for Module<B>

where B: Backend, Module<B>: GGLWEDecompress,

fn decompress_tensor_key<R, O>(&self, res: &mut R, other: &O)

where R: GGLWEToBackendMut<Self::Backend> + GGLWEInfos, O: GGLWECompressedToBackendRef<Self::Backend> + GGLWEInfos,

impl<BE> GLWETensorKeyEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn glwe_tensor_key_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn glwe_tensor_key_encrypt_sk<R, S, E>( &self, res: &mut R, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + GGLWEInfos, E: EncryptionInfos, S: GLWESecretToBackendRef<BE> + GetDistribution + GLWEInfos,

impl<B> GLWETensorKeyPreparedFactory<B> for Module<B>

where B: Backend, Module<B>: GGLWEPreparedFactory<B>,

fn alloc_tensor_key_prepared( &self, base2k: Base2K, k: TorusPrecision, dnum: Dnum, dsize: Dsize, rank: Rank, ) -> GLWETensorKeyPrepared<<B as Backend>::OwnedBuf, B>

fn alloc_tensor_key_prepared_from_infos<A>( &self, infos: &A, ) -> GLWETensorKeyPrepared<<B as Backend>::OwnedBuf, B>

where A: GGLWEInfos,

fn bytes_of_tensor_key_prepared( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, dnum: Dnum, dsize: Dsize, ) -> usize

fn bytes_of_tensor_key_prepared_from_infos<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn prepare_tensor_key_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn prepare_tensor_key<R, O>( &self, res: &mut R, other: &O, scratch: &mut ScratchArena<'_, B>, )

where R: GGLWEPreparedToBackendMut<B>, O: GGLWEToBackendRef<B>,

impl<BE> GLWETensoring<BE> for Module<BE>

where BE: Backend + GLWETensoringImpl<BE>, Module<BE>: GLWETensoringDefault<BE>,

fn glwe_tensor_apply_tmp_bytes<R, A, B>(&self, res: &R, a: &A, b: &B) -> usize

where R: GLWEInfos, A: GLWEInfos, B: GLWEInfos,

fn glwe_tensor_square_apply_tmp_bytes<R, A>(&self, res: &R, a: &A) -> usize

where R: GLWEInfos, A: GLWEInfos,

fn glwe_tensor_apply<R, A, B>( &self, cnv_offset: usize, res: &mut R, a: &A, a_effective_k: usize, b: &B, b_effective_k: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos, B: GLWEToBackendRef<BE> + GLWEInfos,

fn glwe_tensor_square_apply<R, A>( &self, cnv_offset: usize, res: &mut R, a: &A, a_effective_k: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos,

fn glwe_tensor_relinearize<R, A, T>( &self, res: &mut R, a: &A, tsk: &T, tsk_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos, T: GGLWEInfos + GLWETensorKeyPreparedToBackendRef<BE>,

fn glwe_tensor_relinearize_tmp_bytes<R, A, B>( &self, res: &R, a: &A, tsk: &B, ) -> usize

where R: GLWEInfos, A: GLWEInfos, B: GGLWEInfos,

impl<B> GLWEToLWEKeyPreparedFactory<B> for Module<B>

where B: Backend, Module<B>: GLWESwitchingKeyPreparedFactory<B>,

fn glwe_to_lwe_key_prepared_alloc( &self, base2k: Base2K, k: TorusPrecision, rank_in: Rank, dnum: Dnum, ) -> GLWEToLWEKeyPrepared<<B as Backend>::OwnedBuf, B>

fn glwe_to_lwe_key_prepared_alloc_from_infos<A>( &self, infos: &A, ) -> GLWEToLWEKeyPrepared<<B as Backend>::OwnedBuf, B>

where A: GGLWEInfos,

fn glwe_to_lwe_key_prepared_bytes_of( &self, base2k: Base2K, k: TorusPrecision, rank_in: Rank, dnum: Dnum, ) -> usize

fn glwe_to_lwe_key_prepared_bytes_of_from_infos<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn glwe_to_lwe_key_prepare_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn glwe_to_lwe_key_prepare<R, O>( &self, res: &mut R, other: &O, scratch: &mut ScratchArena<'_, B>, )

where R: GGLWEPreparedToBackendMut<B> + GLWESwitchingKeyDegreesMut, O: GGLWEToBackendRef<B> + GLWESwitchingKeyDegrees,

impl<B> GLWEToLWESwitchingKeyDecompress for Module<B>

where B: Backend, Module<B>: GLWESwitchingKeyDecompress,

fn decompress_glwe_to_lwe_key<R, O>(&self, res: &mut R, other: &O)

where R: GGLWEToBackendMut<Self::Backend> + GGLWEInfos + GLWESwitchingKeyDegreesMut, O: GGLWECompressedToBackendRef<Self::Backend> + GGLWEInfos + GLWESwitchingKeyDegrees,

impl<BE> GLWEToLWESwitchingKeyEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn glwe_to_lwe_key_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn glwe_to_lwe_key_encrypt_sk<R, S1, S2, E>( &self, res: &mut R, sk_lwe: &S1, sk_glwe: &S2, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where S1: LWESecretToBackendRef<BE>, S2: GLWESecretToBackendRef<BE>, E: EncryptionInfos, R: GGLWEToBackendMut<BE> + GGLWEInfos,

impl<BE> GLWETrace<BE> for Module<BE>

where BE: Backend + GLWETraceImpl<BE>, Module<BE>: GLWETraceDefault<BE>,

fn glwe_trace_galois_elements(&self) -> Vec<i64>

fn glwe_trace_tmp_bytes<R, A, K>( &self, res_infos: &R, a_infos: &A, key_infos: &K, ) -> usize

where R: GLWEInfos, A: GLWEInfos, K: GGLWEInfos,

fn glwe_trace<R, A, K, H>( &self, res: &mut R, skip: usize, a: &A, keys: &H, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos, K: GGLWEPreparedToBackendRef<BE> + GetGaloisElement + GGLWEInfos, H: GLWEAutomorphismKeyHelper<K, BE>,

fn glwe_trace_assign<R, K, H>( &self, res: &mut R, skip: usize, keys: &H, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: GLWEToBackendMut<BE> + GLWEInfos, K: GGLWEPreparedToBackendRef<BE> + GetGaloisElement + GGLWEInfos, H: GLWEAutomorphismKeyHelper<K, BE>,

impl<BE> GLWEZero<BE> for Module<BE>

where BE: Backend + GLWEZeroImpl<BE>, Module<BE>: GLWEZeroDefault<BE>,

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

where R: GLWEToBackendMut<BE>,

impl<BE> GaloisElement for Module<BE>

where BE: Backend, Module<BE>: CyclotomicOrder,

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

Returns GALOISGENERATOR^|generator| * sign(generator) mod 2N.

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

Returns the inverse of gal_el in the Galois group (Z/2NZ)*.

impl<B> GetDegree for Module<B>

where B: Backend,

fn ring_degree(&self) -> Degree

Returns the ring degree N as a Degree.

impl<B> LWEDecompress for Module<B>

where B: Backend, Module<B>: VecZnxFillUniformSourceBackend<B>,

type Backend = B

fn decompress_lwe<R, O>(&self, res: &mut R, other: &O)

where R: LWEToBackendMut<HostBytesBackend>, O: LWECompressedToBackendRef<HostBytesBackend>,

impl<BE> LWEDecrypt<BE> for Module<BE>

where BE: Backend + HostBackend + DecryptionImpl<BE>,

fn lwe_decrypt<R, P, S>( &self, res: &R, pt: &mut P, sk: &S, scratch: &mut ScratchArena<'_, BE>, )

where R: LWEToBackendRef<BE> + LWEInfos, P: LWEPlaintextToBackendMut<BE> + SetLWEInfos + LWEInfos, S: LWESecretToBackendRef<BE> + LWEInfos,

fn lwe_decrypt_tmp_bytes<A>(&self, infos: &A) -> usize

where A: LWEInfos,

impl<BE> LWEEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn lwe_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: LWEInfos,

fn lwe_encrypt_sk<R, P, S, E>( &self, res: &mut R, pt: &P, sk: &S, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: LWEToBackendMut<BE> + LWEInfos, P: LWEPlaintextToBackendRef<BE>, S: LWESecretToBackendRef<BE>, E: EncryptionInfos,

impl<BE> LWEFromGLWE<BE> for Module<BE>

where BE: Backend + ConversionImpl<BE>, Module<BE>: ConversionDefault<BE>,

fn lwe_from_glwe_tmp_bytes<R, A, K>( &self, lwe_infos: &R, glwe_infos: &A, key_infos: &K, ) -> usize

where R: LWEInfos, A: GLWEInfos, K: GGLWEInfos,

fn lwe_from_glwe<R, A, K>( &self, res: &mut R, a: &A, a_idx: usize, key: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: LWEToBackendMut<BE> + LWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos, K: GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

impl<BE> LWEKeyswitch<BE> for Module<BE>

where BE: Backend + LWEKeyswitchImpl<BE>,

fn lwe_keyswitch_tmp_bytes<R, A, K>( &self, res_infos: &R, a_infos: &A, key_infos: &K, ) -> usize

where R: LWEInfos, A: LWEInfos, K: GGLWEInfos,

fn lwe_keyswitch<R, A, K>( &self, res: &mut R, a: &A, ksk: &K, key_size: usize, scratch: &mut ScratchArena<'_, BE>, )

where R: LWEToBackendMut<BE> + LWEInfos, A: LWEToBackendRef<BE> + LWEInfos, K: GGLWEPreparedToBackendRef<BE> + GGLWEInfos,

impl<BE> LWESampleExtract<BE> for Module<BE>

where BE: Backend + ConversionImpl<BE>, Module<BE>: ConversionDefault<BE>,

fn lwe_sample_extract<R, A>(&self, res: &mut R, a: &A)

where R: LWEToBackendMut<BE> + LWEInfos, A: GLWEToBackendRef<BE> + GLWEInfos,

impl<B> LWESwitchingKeyDecompress for Module<B>

where B: Backend, Module<B>: GLWESwitchingKeyDecompress,

fn decompress_lwe_switching_key<R, O>(&self, res: &mut R, other: &O)

where R: GGLWEToBackendMut<Self::Backend> + GGLWEInfos + GLWESwitchingKeyDegreesMut, O: GGLWECompressedToBackendRef<Self::Backend> + GGLWEInfos + GLWESwitchingKeyDegrees,

impl<BE> LWESwitchingKeyEncrypt<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn lwe_switching_key_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn lwe_switching_key_encrypt_sk<R, S1, S2, E>( &self, res: &mut R, sk_lwe_in: &S1, sk_lwe_out: &S2, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where R: GGLWEToBackendMut<BE> + GLWESwitchingKeyDegreesMut + GGLWEInfos, E: EncryptionInfos, S1: LWESecretToBackendRef<BE>, S2: LWESecretToBackendRef<BE>,

impl<B> LWESwitchingKeyPreparedFactory<B> for Module<B>

where B: Backend, Module<B>: GLWESwitchingKeyPreparedFactory<B>,

fn lwe_switching_key_prepared_alloc( &self, base2k: Base2K, k: TorusPrecision, dnum: Dnum, ) -> LWESwitchingKeyPrepared<<B as Backend>::OwnedBuf, B>

fn lwe_switching_key_prepared_alloc_from_infos<A>( &self, infos: &A, ) -> LWESwitchingKeyPrepared<<B as Backend>::OwnedBuf, B>

where A: GGLWEInfos,

fn lwe_switching_key_prepared_bytes_of( &self, base2k: Base2K, k: TorusPrecision, dnum: Dnum, ) -> usize

fn lwe_switching_key_prepared_bytes_of_from_infos<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn lwe_switching_key_prepare_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn lwe_switching_key_prepare<R, O>( &self, res: &mut R, other: &O, scratch: &mut ScratchArena<'_, B>, )

where R: GGLWEPreparedToBackendMut<B> + GLWESwitchingKeyDegreesMut, O: GGLWEToBackendRef<B> + GLWESwitchingKeyDegrees,

impl<B> LWEToGLWEKeyDecompress for Module<B>

where B: Backend, Module<B>: GLWESwitchingKeyDecompress,

fn decompress_lwe_to_glwe_key<R, O>(&self, res: &mut R, other: &O)

where R: GGLWEToBackendMut<Self::Backend> + GGLWEInfos + GLWESwitchingKeyDegreesMut, O: GGLWECompressedToBackendRef<Self::Backend> + GGLWEInfos + GLWESwitchingKeyDegrees,

impl<B> LWEToGLWEKeyPreparedFactory<B> for Module<B>

where B: Backend, Module<B>: GLWESwitchingKeyPreparedFactory<B>,

fn lwe_to_glwe_key_prepared_alloc( &self, base2k: Base2K, k: TorusPrecision, rank_out: Rank, dnum: Dnum, ) -> LWEToGLWEKeyPrepared<<B as Backend>::OwnedBuf, B>

fn lwe_to_glwe_key_prepared_alloc_from_infos<A>( &self, infos: &A, ) -> LWEToGLWEKeyPrepared<<B as Backend>::OwnedBuf, B>

where A: GGLWEInfos,

fn lwe_to_glwe_key_prepared_bytes_of( &self, base2k: Base2K, k: TorusPrecision, rank_out: Rank, dnum: Dnum, ) -> usize

fn lwe_to_glwe_key_prepared_bytes_of_from_infos<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn lwe_to_glwe_key_prepare_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn lwe_to_glwe_key_prepare<R, O>( &self, res: &mut R, other: &O, scratch: &mut ScratchArena<'_, B>, )

where R: GGLWEPreparedToBackendMut<B> + GLWESwitchingKeyDegreesMut, O: GGLWEToBackendRef<B> + GLWESwitchingKeyDegrees,

impl<BE> LWEToGLWESwitchingKeyEncryptSk<BE> for Module<BE>

where BE: Backend + EncryptionImpl<BE>,

fn lwe_to_glwe_key_encrypt_sk_tmp_bytes<A>(&self, infos: &A) -> usize

where A: GGLWEInfos,

fn lwe_to_glwe_key_encrypt_sk<R, S1, S2, E>( &self, res: &mut R, sk_lwe: &S1, sk_glwe: &S2, enc_infos: &E, source_xe: &mut Source, source_xa: &mut Source, scratch: &mut ScratchArena<'_, BE>, )

where S1: LWESecretToBackendRef<BE>, S2: GLWESecretPreparedToBackendRef<BE>, E: EncryptionInfos, R: GGLWEToBackendMut<BE> + GGLWEInfos,

impl<B> MatZnxAlloc<B> for Module<B>

where B: Backend,

fn mat_znx_alloc( &self, rows: usize, cols_in: usize, cols_out: usize, size: usize, ) -> MatZnx<<B as Backend>::OwnedBuf>

impl<B> ModuleCoreAlloc for Module<B>

where B: Backend,

type OwnedBuf = <B as Backend>::OwnedBuf

fn glwe_alloc_from_infos<A>(&self, infos: &A) -> GLWE<<B as Backend>::OwnedBuf>

where A: GLWEInfos,

fn glwe_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, ) -> GLWE<<B as Backend>::OwnedBuf>

fn gglwe_alloc_from_infos<A>( &self, infos: &A, ) -> GGLWE<<B as Backend>::OwnedBuf>

where A: GGLWEInfos,

fn gglwe_alloc( &self, base2k: Base2K, k: TorusPrecision, rank_in: Rank, rank_out: Rank, dnum: Dnum, dsize: Dsize, ) -> GGLWE<<B as Backend>::OwnedBuf>

fn ggsw_alloc_from_infos<A>(&self, infos: &A) -> GGSW<<B as Backend>::OwnedBuf>

where A: GGSWInfos,

fn ggsw_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, dnum: Dnum, dsize: Dsize, ) -> GGSW<<B as Backend>::OwnedBuf>

fn glwe_plaintext_alloc_from_infos<A>( &self, infos: &A, ) -> GLWEPlaintext<<B as Backend>::OwnedBuf>

where A: GLWEInfos,

fn glwe_plaintext_alloc( &self, base2k: Base2K, k: TorusPrecision, ) -> GLWEPlaintext<<B as Backend>::OwnedBuf>

fn glwe_secret_alloc_from_infos<A>( &self, infos: &A, ) -> GLWESecret<<B as Backend>::OwnedBuf>

where A: GLWEInfos,

fn glwe_secret_alloc(&self, rank: Rank) -> GLWESecret<<B as Backend>::OwnedBuf>

fn glwe_secret_tensor_alloc_from_infos<A>( &self, infos: &A, ) -> GLWESecretTensor<<B as Backend>::OwnedBuf>

where A: GLWEInfos,

fn glwe_secret_tensor_alloc( &self, rank: Rank, ) -> GLWESecretTensor<<B as Backend>::OwnedBuf>

fn glwe_tensor_alloc_from_infos<A>( &self, infos: &A, ) -> GLWETensor<<B as Backend>::OwnedBuf>

where A: GLWEInfos,

fn glwe_tensor_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, ) -> GLWETensor<<B as Backend>::OwnedBuf>

fn glwe_public_key_alloc_from_infos<A>( &self, infos: &A, ) -> GLWEPublicKey<<B as Backend>::OwnedBuf>

where A: GLWEInfos,

fn glwe_public_key_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, ) -> GLWEPublicKey<<B as Backend>::OwnedBuf>

fn glwe_switching_key_alloc_from_infos<A>( &self, infos: &A, ) -> GLWESwitchingKey<<B as Backend>::OwnedBuf>

where A: GGLWEInfos,

fn glwe_switching_key_alloc( &self, base2k: Base2K, k: TorusPrecision, rank_in: Rank, rank_out: Rank, dnum: Dnum, dsize: Dsize, ) -> GLWESwitchingKey<<B as Backend>::OwnedBuf>

fn glwe_automorphism_key_alloc_from_infos<A>( &self, infos: &A, ) -> GLWEAutomorphismKey<<B as Backend>::OwnedBuf>

where A: GGLWEInfos,

fn glwe_automorphism_key_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, dnum: Dnum, dsize: Dsize, ) -> GLWEAutomorphismKey<<B as Backend>::OwnedBuf>

fn glwe_tensor_key_alloc_from_infos<A>( &self, infos: &A, ) -> GLWETensorKey<<B as Backend>::OwnedBuf>

where A: GGLWEInfos,

fn glwe_tensor_key_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, dnum: Dnum, dsize: Dsize, ) -> GLWETensorKey<<B as Backend>::OwnedBuf>

fn glwe_to_lwe_key_alloc_from_infos<A>( &self, infos: &A, ) -> GLWEToLWEKey<<B as Backend>::OwnedBuf>

where A: GGLWEInfos,

fn glwe_to_lwe_key_alloc( &self, base2k: Base2K, k: TorusPrecision, rank_in: Rank, dnum: Dnum, ) -> GLWEToLWEKey<<B as Backend>::OwnedBuf>

fn gglwe_to_ggsw_key_alloc_from_infos<A>( &self, infos: &A, ) -> GGLWEToGGSWKey<<B as Backend>::OwnedBuf>

where A: GGLWEInfos,

fn gglwe_to_ggsw_key_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, dnum: Dnum, dsize: Dsize, ) -> GGLWEToGGSWKey<<B as Backend>::OwnedBuf>

fn lwe_alloc_from_infos<A>(&self, infos: &A) -> LWE<<B as Backend>::OwnedBuf>

where A: LWEInfos,

fn lwe_alloc( &self, n: Degree, base2k: Base2K, k: TorusPrecision, ) -> LWE<<B as Backend>::OwnedBuf>

fn lwe_plaintext_alloc_from_infos<A>( &self, infos: &A, ) -> LWEPlaintext<<B as Backend>::OwnedBuf>

where A: LWEInfos,

fn lwe_plaintext_alloc( &self, base2k: Base2K, k: TorusPrecision, ) -> LWEPlaintext<<B as Backend>::OwnedBuf>

fn lwe_secret_alloc(&self, n: Degree) -> LWESecret<<B as Backend>::OwnedBuf>

fn lwe_switching_key_alloc_from_infos<A>( &self, infos: &A, ) -> LWESwitchingKey<<B as Backend>::OwnedBuf>

where A: GGLWEInfos,

fn lwe_switching_key_alloc( &self, n: Degree, base2k: Base2K, k: TorusPrecision, dnum: Dnum, ) -> LWESwitchingKey<<B as Backend>::OwnedBuf>

fn lwe_to_glwe_key_alloc_from_infos<A>( &self, infos: &A, ) -> LWEToGLWEKey<<B as Backend>::OwnedBuf>

where A: GGLWEInfos,

fn lwe_to_glwe_key_alloc( &self, n: Degree, base2k: Base2K, k: TorusPrecision, rank_out: Rank, dnum: Dnum, ) -> LWEToGLWEKey<<B as Backend>::OwnedBuf>

impl<B> ModuleCoreCompressedAlloc for Module<B>

where B: Backend,

fn glwe_compressed_alloc_from_infos<A>( &self, infos: &A, ) -> GLWECompressed<Vec<u8>>

where A: GLWEInfos,

fn glwe_compressed_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, ) -> GLWECompressed<Vec<u8>>

fn lwe_compressed_alloc_from_infos<A>( &self, infos: &A, ) -> LWECompressed<Vec<u8>>

where A: LWEInfos,

fn lwe_compressed_alloc( &self, base2k: Base2K, k: TorusPrecision, ) -> LWECompressed<Vec<u8>>

fn gglwe_compressed_alloc_from_infos<A>( &self, infos: &A, ) -> GGLWECompressed<Vec<u8>>

where A: GGLWEInfos,

fn gglwe_compressed_alloc( &self, base2k: Base2K, k: TorusPrecision, rank_in: Rank, rank_out: Rank, dnum: Dnum, dsize: Dsize, ) -> GGLWECompressed<Vec<u8>>

fn ggsw_compressed_alloc_from_infos<A>( &self, infos: &A, ) -> GGSWCompressed<Vec<u8>>

where A: GGSWInfos,

fn ggsw_compressed_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, dnum: Dnum, dsize: Dsize, ) -> GGSWCompressed<Vec<u8>>

fn glwe_switching_key_compressed_alloc_from_infos<A>( &self, infos: &A, ) -> GLWESwitchingKeyCompressed<Vec<u8>>

where A: GGLWEInfos,

fn glwe_switching_key_compressed_alloc( &self, base2k: Base2K, k: TorusPrecision, rank_in: Rank, rank_out: Rank, dnum: Dnum, dsize: Dsize, ) -> GLWESwitchingKeyCompressed<Vec<u8>>

fn glwe_automorphism_key_compressed_alloc_from_infos<A>( &self, infos: &A, ) -> GLWEAutomorphismKeyCompressed<Vec<u8>>

where A: GGLWEInfos,

fn glwe_automorphism_key_compressed_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, dnum: Dnum, dsize: Dsize, ) -> GLWEAutomorphismKeyCompressed<Vec<u8>>

fn glwe_tensor_key_compressed_alloc_from_infos<A>( &self, infos: &A, ) -> GLWETensorKeyCompressed<Vec<u8>>

where A: GGLWEInfos,

fn glwe_tensor_key_compressed_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, dnum: Dnum, dsize: Dsize, ) -> GLWETensorKeyCompressed<Vec<u8>>

fn glwe_to_lwe_key_compressed_alloc_from_infos<A>( &self, infos: &A, ) -> GLWEToLWESwitchingKeyCompressed<Vec<u8>>

where A: GGLWEInfos,

fn glwe_to_lwe_key_compressed_alloc( &self, base2k: Base2K, k: TorusPrecision, rank_in: Rank, dnum: Dnum, ) -> GLWEToLWESwitchingKeyCompressed<Vec<u8>>

fn lwe_to_glwe_key_compressed_alloc_from_infos<A>( &self, infos: &A, ) -> LWEToGLWEKeyCompressed<Vec<u8>>

where A: GGLWEInfos,

fn lwe_to_glwe_key_compressed_alloc( &self, n: Degree, base2k: Base2K, k: TorusPrecision, rank_out: Rank, dnum: Dnum, ) -> LWEToGLWEKeyCompressed<Vec<u8>>

fn lwe_switching_key_compressed_alloc_from_infos<A>( &self, infos: &A, ) -> LWESwitchingKeyCompressed<Vec<u8>>

where A: GGLWEInfos,

fn lwe_switching_key_compressed_alloc( &self, n: Degree, base2k: Base2K, k: TorusPrecision, dnum: Dnum, ) -> LWESwitchingKeyCompressed<Vec<u8>>

fn gglwe_to_ggsw_key_compressed_alloc_from_infos<A>( &self, infos: &A, ) -> GGLWEToGGSWKeyCompressed<Vec<u8>>

where A: GGLWEInfos,

fn gglwe_to_ggsw_key_compressed_alloc( &self, base2k: Base2K, k: TorusPrecision, rank: Rank, dnum: Dnum, dsize: Dsize, ) -> GGLWEToGGSWKeyCompressed<Vec<u8>>

impl<BE> ModuleLogN for Module<BE>

where BE: Backend, Module<BE>: 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 + HalModuleImpl<B>,

fn new(n: u64) -> Module<B>

impl<To> ModuleTransfer<To> for Module<To>

where To: Backend,

fn upload_glwe<From>( &self, src: &GLWE<<From as Backend>::OwnedBuf>, ) -> GLWE<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn download_glwe<From>( &self, src: &GLWE<<From as Backend>::OwnedBuf>, ) -> GLWE<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn upload_lwe<From>( &self, src: &LWE<<From as Backend>::OwnedBuf>, ) -> LWE<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn download_lwe<From>( &self, src: &LWE<<From as Backend>::OwnedBuf>, ) -> LWE<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn upload_gglwe<From>( &self, src: &GGLWE<<From as Backend>::OwnedBuf>, ) -> GGLWE<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn download_gglwe<From>( &self, src: &GGLWE<<From as Backend>::OwnedBuf>, ) -> GGLWE<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn upload_ggsw<From>( &self, src: &GGSW<<From as Backend>::OwnedBuf>, ) -> GGSW<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn download_ggsw<From>( &self, src: &GGSW<<From as Backend>::OwnedBuf>, ) -> GGSW<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn upload_glwe_secret<From>( &self, src: &GLWESecret<<From as Backend>::OwnedBuf>, ) -> GLWESecret<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn download_glwe_secret<From>( &self, src: &GLWESecret<<From as Backend>::OwnedBuf>, ) -> GLWESecret<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn upload_lwe_secret<From>( &self, src: &LWESecret<<From as Backend>::OwnedBuf>, ) -> LWESecret<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn download_lwe_secret<From>( &self, src: &LWESecret<<From as Backend>::OwnedBuf>, ) -> LWESecret<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn upload_glwe_plaintext<From>( &self, src: &GLWEPlaintext<<From as Backend>::OwnedBuf>, ) -> GLWEPlaintext<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn download_glwe_plaintext<From>( &self, src: &GLWEPlaintext<<From as Backend>::OwnedBuf>, ) -> GLWEPlaintext<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn upload_lwe_plaintext<From>( &self, src: &LWEPlaintext<<From as Backend>::OwnedBuf>, ) -> LWEPlaintext<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

fn download_lwe_plaintext<From>( &self, src: &LWEPlaintext<<From as Backend>::OwnedBuf>, ) -> LWEPlaintext<<To as Backend>::OwnedBuf>

where From: Backend, To: TransferFrom<From>,

impl<B> NttModuleHandle for Module<B>

where B: Backend, B::Handle: NttHandleProvider,

Blanket impl: any Module<B> whose handle implements NttHandleProvider automatically satisfies NttModuleHandle.

fn get_ntt_table(&self) -> &NttTable<Primes30>

Precomputed forward NTT twiddle table (Primes30, size n).

fn get_intt_table(&self) -> &NttTableInv<Primes30>

Precomputed inverse NTT twiddle table (Primes30, size n).

fn get_bbc_meta(&self) -> &BbcMeta<Primes30>

Precomputed metadata for q120b × q120c lazy multiply–accumulate.

fn get_bbb_meta(&self) -> &BbbMeta<Primes30>

Precomputed metadata for q120b × q120b lazy multiply–accumulate.

impl<B> ScalarZnxAlloc<B> for Module<B>

where B: Backend,

fn scalar_znx_alloc(&self, cols: usize) -> ScalarZnx<<B as Backend>::OwnedBuf>

impl<B> ScalarZnxFillBinaryBlockBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn scalar_znx_fill_binary_block_backend( &self, res: &mut ScalarZnx<<B as Backend>::BufMut<'_>>, res_col: usize, block_size: usize, seed: [u8; 32], )

impl<B> ScalarZnxFillBinaryBlockSourceBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn scalar_znx_fill_binary_block_source_backend( &self, res: &mut ScalarZnx<<B as Backend>::BufMut<'_>>, res_col: usize, block_size: usize, source: &mut Source, )

impl<B> ScalarZnxFillBinaryHwBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn scalar_znx_fill_binary_hw_backend( &self, res: &mut ScalarZnx<<B as Backend>::BufMut<'_>>, res_col: usize, hw: usize, seed: [u8; 32], )

impl<B> ScalarZnxFillBinaryHwSourceBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn scalar_znx_fill_binary_hw_source_backend( &self, res: &mut ScalarZnx<<B as Backend>::BufMut<'_>>, res_col: usize, hw: usize, source: &mut Source, )

impl<B> ScalarZnxFillBinaryProbBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn scalar_znx_fill_binary_prob_backend( &self, res: &mut ScalarZnx<<B as Backend>::BufMut<'_>>, res_col: usize, prob: f64, seed: [u8; 32], )

impl<B> ScalarZnxFillBinaryProbSourceBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn scalar_znx_fill_binary_prob_source_backend( &self, res: &mut ScalarZnx<<B as Backend>::BufMut<'_>>, res_col: usize, prob: f64, source: &mut Source, )

impl<B> ScalarZnxFillTernaryHwBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn scalar_znx_fill_ternary_hw_backend( &self, res: &mut ScalarZnx<<B as Backend>::BufMut<'_>>, res_col: usize, hw: usize, seed: [u8; 32], )

impl<B> ScalarZnxFillTernaryHwSourceBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn scalar_znx_fill_ternary_hw_source_backend( &self, res: &mut ScalarZnx<<B as Backend>::BufMut<'_>>, res_col: usize, hw: usize, source: &mut Source, )

impl<B> ScalarZnxFillTernaryProbBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn scalar_znx_fill_ternary_prob_backend( &self, res: &mut ScalarZnx<<B as Backend>::BufMut<'_>>, res_col: usize, prob: f64, seed: [u8; 32], )

impl<B> ScalarZnxFillTernaryProbSourceBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn scalar_znx_fill_ternary_prob_source_backend( &self, res: &mut ScalarZnx<<B as Backend>::BufMut<'_>>, res_col: usize, prob: f64, source: &mut Source, )

impl<B> SecretConversion<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn glwe_secret_from_lwe_secret<S>( &self, src: &S, ) -> GLWESecret<<B as Backend>::OwnedBuf>

where S: LWESecretToBackendRef<B>,

Derives the associated rank-1 GLWESecret from a LWESecret by applying the X → X⁻¹ automorphism (k = -1). The result is the GLWE polynomial key whose ring product with a mask decrypts LWE ciphertexts produced by glwe_expand_lwe.

fn lwe_secret_from_glwe_secret<S>( &self, src: &S, ) -> LWESecret<<B as Backend>::OwnedBuf>

where S: GLWESecretToBackendRef<B>,

Derives the associated LWESecret from a GLWESecret by applying the X → X⁻¹ automorphism (k = -1) to each rank component.

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

where B: Backend + HalSvpImpl<B>,

fn svp_apply_dft( &self, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &SvpPPol<<B as Backend>::BufRef<'_>, B>, a_col: usize, b: &VecZnx<<B as Backend>::BufRef<'_>>, b_col: usize, )

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

where B: Backend + HalSvpImpl<B>,

fn svp_apply_dft_to_dft( &self, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &SvpPPol<<B as Backend>::BufRef<'_>, B>, a_col: usize, b: &VecZnxDft<<B as Backend>::BufRef<'_>, B>, b_col: usize, )

impl<B> SvpApplyDftToDftAssign<B> for Module<B>

where B: Backend + HalSvpImpl<B>,

fn svp_apply_dft_to_dft_assign( &self, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &SvpPPol<<B as Backend>::BufRef<'_>, B>, a_col: usize, )

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

where B: Backend,

fn svp_ppol_alloc(&self, cols: usize) -> SvpPPol<<B as Backend>::OwnedBuf, B>

impl<B> SvpPPolBytesOf for Module<B>

where B: Backend,

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

impl<B> SvpPPolCopyBackend<B> for Module<B>

where B: Backend + HalSvpImpl<B>,

fn svp_ppol_copy_backend( &self, res: &mut SvpPPol<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &SvpPPol<<B as Backend>::BufRef<'_>, B>, a_col: usize, )

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

where B: Backend + HalSvpImpl<B>,

fn svp_prepare( &self, res: &mut SvpPPol<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &ScalarZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

impl<B> VecZnxAddAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_add_assign_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

impl<B> VecZnxAddConstAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_add_const_assign_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, cnst: &VecZnx<<B as Backend>::BufRef<'_>>, cnst_col: usize, cnst_coeff: usize, res_limb: usize, res_coeff: usize, )

impl<B> VecZnxAddConstIntoBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_add_const_into_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, cnst: &VecZnx<<B as Backend>::BufRef<'_>>, cnst_col: usize, cnst_coeff: usize, res_limb: usize, res_coeff: usize, )

impl<B> VecZnxAddIntoBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_add_into_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, b: &VecZnx<<B as Backend>::BufRef<'_>>, b_col: usize, )

Adds the selected backend-native column of a to the selected backend-native column of b.

impl<B> VecZnxAddNormalBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_add_normal_backend( &self, base2k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, noise_infos: NoiseInfos, seed: [u8; 32], )

Adds backend-defined normal noise to the selected backend-native column using seed.

impl<B> VecZnxAddNormalSourceBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_add_normal_source_backend( &self, base2k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, noise_infos: NoiseInfos, source_xe: &mut Source, )

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

impl<B> VecZnxAddScalarAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_add_scalar_assign_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, res_limb: usize, a: &ScalarZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

impl<B> VecZnxAddScalarIntoBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_add_scalar_into_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &ScalarZnx<<B as Backend>::BufRef<'_>>, a_col: usize, b: &VecZnx<<B as Backend>::BufRef<'_>>, b_col: usize, b_limb: usize, )

impl<B> VecZnxAlloc<B> for Module<B>

where B: Backend,

fn vec_znx_alloc( &self, cols: usize, size: usize, ) -> VecZnx<<B as Backend>::OwnedBuf>

fn vec_znx_alloc_with_max_size( &self, cols: usize, size: usize, max_size: usize, ) -> VecZnx<<B as Backend>::OwnedBuf>

impl<B> VecZnxAutomorphismAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_automorphism_assign_backend( &self, k: i64, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, scratch: &mut ScratchArena<'_, B>, )

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

impl<B> VecZnxAutomorphismAssignTmpBytes for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_automorphism_assign_tmp_bytes(&self) -> usize

impl<B> VecZnxAutomorphismBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_automorphism_backend( &self, k: i64, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

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> VecZnxBigAddAssign<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_add_assign( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, a_col: usize, )

Adds a to b and stores the result on b.

impl<B> VecZnxBigAddInto<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_add_into( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, a_col: usize, b: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, b_col: usize, )

Adds a to b and stores the result on c.

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

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_add_normal( &self, base2k: usize, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, noise_infos: NoiseInfos, source: &mut Source, )

impl<B> VecZnxBigAddNormalBackend<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_add_normal_backend( &self, base2k: usize, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, noise_infos: NoiseInfos, seed: [u8; 32], )

impl<B> VecZnxBigAddSmallAssign<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_add_small_assign( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

Adds a to b and stores the result on b.

impl<B> VecZnxBigAddSmallIntoBackend<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_add_small_into_backend( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, a_col: usize, b: &VecZnx<<B as Backend>::BufRef<'_>>, b_col: usize, )

Adds a to b and stores the result on c.

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

where B: Backend,

fn vec_znx_big_alloc( &self, cols: usize, size: usize, ) -> VecZnxBig<<B as Backend>::OwnedBuf, B>

fn vec_znx_big_alloc_n( &self, n: usize, cols: usize, size: usize, ) -> VecZnxBig<<B as Backend>::OwnedBuf, B>

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

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_automorphism( &self, k: i64, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, a_col: usize, )

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

impl<B> VecZnxBigAutomorphismAssign<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_automorphism_assign( &self, k: i64, a: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

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

impl<B> VecZnxBigAutomorphismAssignTmpBytes for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_automorphism_assign_tmp_bytes(&self) -> usize

impl<B> VecZnxBigBytesOf for Module<B>

where B: Backend,

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

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

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

where B: Backend,

fn vec_znx_big_from_bytes( &self, cols: usize, size: usize, bytes: Vec<u8>, ) -> VecZnxBig<<B as Backend>::OwnedBuf, B>

fn vec_znx_big_from_bytes_n( &self, n: usize, cols: usize, size: usize, bytes: Vec<u8>, ) -> VecZnxBig<<B as Backend>::OwnedBuf, B>

impl<B> VecZnxBigFromSmallBackend<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_from_small_backend( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

impl<B> VecZnxBigInnerSumBackend<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_inner_sum_backend( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, res_coeff: usize, a: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, a_col: usize, )

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

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_negate( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, a_col: usize, )

impl<B> VecZnxBigNegateAssign<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_negate_assign( &self, a: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, a_col: usize, )

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

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_normalize( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_base2k: usize, res_offset: i64, res_col: usize, a: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, a_base2k: usize, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

impl<B> VecZnxBigNormalizeTmpBytes for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_normalize_tmp_bytes(&self) -> usize

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

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_sub( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, a_col: usize, b: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, b_col: usize, )

Subtracts a to b and stores the result on c.

impl<B> VecZnxBigSubAssign<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_sub_assign( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, a_col: usize, )

Subtracts a from b and stores the result on b.

impl<B> VecZnxBigSubNegateAssign<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_sub_negate_assign( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, a_col: usize, )

Subtracts b from a and stores the result on b.

impl<B> VecZnxBigSubSmallABackend<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_sub_small_a_backend( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, b: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, b_col: usize, )

Subtracts b from a and stores the result on c.

impl<B> VecZnxBigSubSmallAssign<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_sub_small_assign( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

Subtracts a from res and stores the result on res.

impl<B> VecZnxBigSubSmallBBackend<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_sub_small_b_backend( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxBig<<B as Backend>::BufRef<'_>, B>, a_col: usize, b: &VecZnx<<B as Backend>::BufRef<'_>>, b_col: usize, )

Subtracts b from a and stores the result on c.

impl<B> VecZnxBigSubSmallNegateAssign<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_big_sub_small_negate_assign( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

Subtracts res from a and stores the result on res.

impl<B> VecZnxCopyBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_copy_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

impl<B> VecZnxCopyRangeBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_copy_range_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, res_limb: usize, res_offset: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, a_limb: usize, a_offset: usize, len: usize, )

impl<B> VecZnxDftAddAssign<B> for Module<B>

where B: Backend + HalVecZnxDftImpl<B>,

fn vec_znx_dft_add_assign( &self, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxDft<<B as Backend>::BufRef<'_>, B>, a_col: usize, )

impl<B> VecZnxDftAddInto<B> for Module<B>

where B: Backend + HalVecZnxDftImpl<B>,

fn vec_znx_dft_add_into( &self, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxDft<<B as Backend>::BufRef<'_>, B>, a_col: usize, b: &VecZnxDft<<B as Backend>::BufRef<'_>, B>, b_col: usize, )

impl<B> VecZnxDftAddScaledAssign<B> for Module<B>

where B: Backend + HalVecZnxDftImpl<B>,

fn vec_znx_dft_add_scaled_assign( &self, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxDft<<B as Backend>::BufRef<'_>, B>, a_col: usize, a_scale: i64, )

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

where B: Backend,

fn vec_znx_dft_alloc( &self, cols: usize, size: usize, ) -> VecZnxDft<<B as Backend>::OwnedBuf, B>

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

where B: Backend + HalVecZnxDftImpl<B>,

fn vec_znx_dft_apply( &self, step: usize, offset: usize, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

impl<B> VecZnxDftBytesOf for Module<B>

where B: Backend,

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

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

where B: Backend + HalVecZnxDftImpl<B>,

fn vec_znx_dft_copy( &self, step: usize, offset: usize, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxDft<<B as Backend>::BufRef<'_>, B>, a_col: usize, )

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

where B: Backend,

fn vec_znx_dft_from_bytes( &self, cols: usize, size: usize, bytes: Vec<u8>, ) -> VecZnxDft<<B as Backend>::OwnedBuf, B>

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

where B: Backend + HalVecZnxDftImpl<B>,

fn vec_znx_dft_sub( &self, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxDft<<B as Backend>::BufRef<'_>, B>, a_col: usize, b: &VecZnxDft<<B as Backend>::BufRef<'_>, B>, b_col: usize, )

impl<B> VecZnxDftSubAssign<B> for Module<B>

where B: Backend + HalVecZnxDftImpl<B>,

fn vec_znx_dft_sub_assign( &self, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxDft<<B as Backend>::BufRef<'_>, B>, a_col: usize, )

impl<B> VecZnxDftSubNegateAssign<B> for Module<B>

where B: Backend + HalVecZnxDftImpl<B>,

fn vec_znx_dft_sub_negate_assign( &self, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxDft<<B as Backend>::BufRef<'_>, B>, a_col: usize, )

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

where B: Backend + HalVecZnxDftImpl<B>,

fn vec_znx_dft_zero( &self, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, res_col: usize, )

impl<B> VecZnxExtractCoeffBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_extract_coeff_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, a_coeff: usize, )

impl<B> VecZnxFillNormalBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_fill_normal_backend( &self, base2k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, noise_infos: NoiseInfos, seed: [u8; 32], )

Fills the selected backend-native column from a backend-defined normal sampler seeded by seed.

impl<B> VecZnxFillNormalSourceBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_fill_normal_source_backend( &self, base2k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, noise_infos: NoiseInfos, source_xe: &mut Source, )

impl<B> VecZnxFillUniformBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_fill_uniform_backend( &self, base2k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, seed: [u8; 32], )

Fills the selected backend-native column from a backend-defined uniform sampler seeded by seed.

impl<B> VecZnxFillUniformSourceBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_fill_uniform_source_backend( &self, base2k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, source: &mut Source, )

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

impl<B> VecZnxHadamardProductScalarZnxBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_hadamard_product_scalar_znx_backend( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, b: &ScalarZnx<<B as Backend>::BufRef<'_>>, b_col: usize, )

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

where B: Backend + HalVecZnxDftImpl<B>,

fn vec_znx_idft_apply( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnxDft<<B as Backend>::BufRef<'_>, B>, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

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

where B: Backend + HalVecZnxDftImpl<B>,

fn vec_znx_idft_apply_tmpa( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, a_col: usize, )

impl<B> VecZnxIdftApplyTmpBytes for Module<B>

where B: Backend + HalVecZnxDftImpl<B>,

fn vec_znx_idft_apply_tmp_bytes(&self) -> usize

impl<B> VecZnxLshAddCoeffIntoBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_lsh_add_coeff_into_backend( &self, base2k: usize, k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, a_coeff: usize, scratch: &mut ScratchArena<'_, B>, )

impl<B> VecZnxLshAddIntoBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_lsh_add_into_backend( &self, base2k: usize, k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

Left shift by k bits all columns of a.

impl<B> VecZnxLshAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_lsh_assign_backend( &self, base2k: usize, k: usize, a: &mut VecZnx<<B as Backend>::BufMut<'_>>, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

Left shift by k bits all columns of a.

impl<B> VecZnxLshBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_lsh_backend( &self, base2k: usize, k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

Left shift by k bits all columns of a.

impl<B> VecZnxLshCoeffBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_lsh_coeff_backend( &self, base2k: usize, k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, a_coeff: usize, scratch: &mut ScratchArena<'_, B>, )

impl<B> VecZnxLshSubBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_lsh_sub_backend( &self, base2k: usize, k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

Left shift by k bits and subtract from destination.

impl<B> VecZnxLshTmpBytes for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_lsh_tmp_bytes(&self) -> usize

impl<B> VecZnxMergeRingsBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_merge_rings_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &[VecZnx<<B as Backend>::BufRef<'_>>], a_col: usize, scratch: &mut ScratchArena<'_, B>, )

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

impl<B> VecZnxMergeRingsTmpBytes for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_merge_rings_tmp_bytes(&self) -> usize

impl<B> VecZnxMulXpMinusOneAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_mul_xp_minus_one_assign_backend( &self, p: i64, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, scratch: &mut ScratchArena<'_, B>, )

impl<B> VecZnxMulXpMinusOneAssignTmpBytes for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_mul_xp_minus_one_assign_tmp_bytes(&self) -> usize

impl<B> VecZnxMulXpMinusOneBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_mul_xp_minus_one_backend( &self, p: i64, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

impl<B> VecZnxNegateAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_negate_assign_backend( &self, a: &mut VecZnx<<B as Backend>::BufMut<'_>>, a_col: usize, )

impl<B> VecZnxNegateBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_negate_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

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

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_normalize( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_base2k: usize, res_offset: i64, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_base2k: usize, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

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

impl<B> VecZnxNormalizeAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_normalize_assign_backend( &self, base2k: usize, a: &mut VecZnx<<B as Backend>::BufMut<'_>>, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

impl<B> VecZnxNormalizeCoeffAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_normalize_coeff_assign_backend( &self, base2k: usize, a: &mut VecZnx<<B as Backend>::BufMut<'_>>, a_col: usize, a_coeff: usize, scratch: &mut ScratchArena<'_, B>, )

impl<B> VecZnxNormalizeCoeffBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_normalize_coeff_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_base2k: usize, res_offset: i64, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_base2k: usize, a_col: usize, a_coeff: usize, scratch: &mut ScratchArena<'_, B>, )

Normalizes the selected coefficient of a across its limbs into a 1-coeff destination column.

impl<B> VecZnxNormalizeTmpBytes for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_normalize_tmp_bytes(&self) -> usize

Returns the minimum number of bytes necessary for normalization.

impl<B> VecZnxRotateAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_rotate_assign_backend( &self, k: i64, a: &mut VecZnx<<B as Backend>::BufMut<'_>>, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

Multiplies the selected column of a by X^k.

impl<B> VecZnxRotateAssignTmpBytes for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_rotate_assign_tmp_bytes(&self) -> usize

impl<B> VecZnxRotateBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_rotate_backend( &self, k: i64, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

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

impl<B> VecZnxRshAddCoeffIntoBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_rsh_add_coeff_into_backend( &self, base2k: usize, k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, a_coeff: usize, res_coeff: usize, scratch: &mut ScratchArena<'_, B>, )

impl<B> VecZnxRshAddIntoBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_rsh_add_into_backend( &self, base2k: usize, k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

Right shift by k bits all columns of a.

impl<B> VecZnxRshAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_rsh_assign_backend( &self, base2k: usize, k: usize, a: &mut VecZnx<<B as Backend>::BufMut<'_>>, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

Right shift by k bits all columns of a.

impl<B> VecZnxRshBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_rsh_backend( &self, base2k: usize, k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

Right shift by k bits all columns of a.

impl<B> VecZnxRshCoeffBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_rsh_coeff_backend( &self, base2k: usize, k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, a_coeff: usize, scratch: &mut ScratchArena<'_, B>, )

impl<B> VecZnxRshSubBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_rsh_sub_backend( &self, base2k: usize, k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

Right shift by k bits and subtract from destination.

impl<B> VecZnxRshSubCoeffIntoBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_rsh_sub_coeff_into_backend( &self, base2k: usize, k: usize, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, a_coeff: usize, res_coeff: usize, scratch: &mut ScratchArena<'_, B>, )

impl<B> VecZnxRshTmpBytes for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_rsh_tmp_bytes(&self) -> usize

impl<B> VecZnxScalarProduct<B> for Module<B>

where B: Backend + HalVecZnxBigImpl<B>,

fn vec_znx_scalar_product( &self, res: &mut VecZnxBig<<B as Backend>::BufMut<'_>, B>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, b: &ScalarZnx<<B as Backend>::BufRef<'_>>, b_col: usize, )

impl<B> VecZnxSplitRingBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_split_ring_backend( &self, res: &mut [VecZnx<<B as Backend>::BufMut<'_>>], res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, scratch: &mut ScratchArena<'_, B>, )

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 + HalVecZnxImpl<B>,

fn vec_znx_split_ring_tmp_bytes(&self) -> usize

impl<B> VecZnxSubAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_sub_assign_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

impl<B> VecZnxSubBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_sub_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, b: &VecZnx<<B as Backend>::BufRef<'_>>, b_col: usize, )

impl<B> VecZnxSubNegateAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_sub_negate_assign_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

impl<B> VecZnxSubScalarAssignBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_sub_scalar_assign_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, res_limb: usize, a: &ScalarZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

impl<B> VecZnxSubScalarBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_sub_scalar_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &ScalarZnx<<B as Backend>::BufRef<'_>>, a_col: usize, b: &VecZnx<<B as Backend>::BufRef<'_>>, b_col: usize, b_limb: usize, )

impl<B> VecZnxSwitchRingBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_switch_ring_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, a: &VecZnx<<B as Backend>::BufRef<'_>>, a_col: usize, )

impl<B> VecZnxZeroBackend<B> for Module<B>

where B: Backend + HalVecZnxImpl<B>,

fn vec_znx_zero_backend( &self, res: &mut VecZnx<<B as Backend>::BufMut<'_>>, res_col: usize, )

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

where B: Backend + HalVmpImpl<B>,

fn vmp_apply_dft<R>( &self, res: &mut R, a: &VecZnx<<B as Backend>::BufRef<'_>>, b: &VmpPMat<<B as Backend>::BufRef<'_>, B>, scratch: &mut ScratchArena<'_, B>, )

where R: VecZnxDftToBackendMut<B>,

impl<B> VmpApplyDftTmpBytes for Module<B>

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

fn vmp_apply_dft_to_dft( &self, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, a: &VecZnxDft<<B as Backend>::BufRef<'_>, B>, b: &VmpPMat<<B as Backend>::BufRef<'_>, B>, limb_offset: usize, scratch: &mut ScratchArena<'_, B>, )

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

impl<B> VmpApplyDftToDftAccumulate<B> for Module<B>

where B: Backend + HalVmpImpl<B>,

fn vmp_apply_dft_to_dft_accumulate( &self, res: &mut VecZnxDft<<B as Backend>::BufMut<'_>, B>, a: &VecZnxDft<<B as Backend>::BufRef<'_>, B>, b: &VmpPMat<<B as Backend>::BufRef<'_>, B>, limb_offset: usize, scratch: &mut ScratchArena<'_, B>, )

Fused res += a · pmat, shifted by limb_offset limbs.

impl<B> VmpApplyDftToDftAccumulateTmpBytes for Module<B>

where B: Backend + HalVmpImpl<B>,

fn vmp_apply_dft_to_dft_accumulate_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 + HalVmpImpl<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,

fn vmp_pmat_alloc( &self, rows: usize, cols_in: usize, cols_out: usize, size: usize, ) -> VmpPMat<<B as Backend>::OwnedBuf, B>

impl<B> VmpPMatBytesOf for Module<B>

where B: Backend,

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

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

where B: Backend + HalVmpImpl<B>,

fn vmp_prepare( &self, res: &mut VmpPMat<<B as Backend>::BufMut<'_>, B>, a: &MatZnx<<B as Backend>::BufRef<'_>>, scratch: &mut ScratchArena<'_, B>, )

impl<B> VmpPrepareTmpBytes for Module<B>

where B: Backend + HalVmpImpl<B>,

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

impl<B> VmpZero<B> for Module<B>

where B: Backend + HalVmpImpl<B>,

fn vmp_zero(&self, res: &mut VmpPMat<<B as Backend>::BufMut<'_>, B>)

impl<B> Send for Module<B>

where B: Backend,

impl<B> Sync for Module<B>

where B: Backend,