Struct LWE 

pub struct LWE<D: Data> { /* private fields */ }

Implementations

impl LWE<Vec<u8>>

pub fn from_glwe_tmp_bytes<R, A, K, M, BE: Backend>( module: &M, lwe_infos: &R, glwe_infos: &A, key_infos: &K, ) -> usize

where R: LWEInfos, A: GLWEInfos, K: GGLWEInfos, M: LWEFromGLWE<BE>,

impl<D: DataMut> LWE<D>

pub fn sample_extract<A, M>(&mut self, module: &M, a: &A)

where A: GLWEToRef, M: LWESampleExtract,

pub fn from_glwe<A, K, M, BE: Backend>( &mut self, module: &M, a: &A, key: &K, scratch: &mut Scratch<BE>, )

where A: GLWEToRef, K: GGLWEPreparedToRef<BE> + GGLWEInfos, M: LWEFromGLWE<BE>, Scratch<BE>: ScratchTakeCore<BE>,

impl<DataSelf: DataRef + DataMut> LWE<DataSelf>

pub fn decrypt<P, S, M, B: Backend>(&mut self, module: &M, pt: &mut P, sk: &S)

where P: LWEPlaintextToMut, S: LWESecretToRef, M: LWEDecrypt<B>,

impl<DataSelf: DataMut> LWE<DataSelf>

pub fn encrypt_sk<P, S, M, BE: Backend>( &mut self, module: &M, pt: &P, sk: &S, source_xa: &mut Source, source_xe: &mut Source, )

where P: LWEPlaintextToRef, S: LWESecretToRef, M: LWEEncryptSk<BE>,

impl LWE<Vec<u8>>

pub fn keyswitch_tmp_bytes<M, R, A, K, BE: Backend>( module: &M, res_infos: &R, a_infos: &A, key_infos: &K, ) -> usize

where R: LWEInfos, A: LWEInfos, K: GGLWEInfos, M: LWEKeySwitch<BE>,

impl<D: DataMut> LWE<D>

pub fn keyswitch<M, A, K, BE: Backend>( &mut self, module: &M, a: &A, ksk: &K, scratch: &mut Scratch<BE>, )

where A: LWEToRef, K: GGLWEPreparedToRef<BE> + GGLWEInfos, Scratch<BE>: ScratchTakeCore<BE>, M: LWEKeySwitch<BE>,

impl<D: DataRef> LWE<D>

pub fn data(&self) -> &Zn<D>

impl<D: DataMut> LWE<D>

pub fn data_mut(&mut self) -> &Zn<D>

impl LWE<Vec<u8>>

pub fn alloc_from_infos<A>(infos: &A) -> Self

where A: LWEInfos,

pub fn alloc(n: Degree, base2k: Base2K, k: TorusPrecision) -> Self

pub fn bytes_of_from_infos<A>(infos: &A) -> usize

where A: LWEInfos,

pub fn bytes_of(n: Degree, base2k: Base2K, k: TorusPrecision) -> usize

impl<D: DataMut> LWE<D>

pub fn decompress<O, M>(&mut self, module: &M, other: &O)

where O: LWECompressedToRef, M: LWEDecompress,

Trait Implementations

impl<D: Clone + Data> Clone for LWE<D>

fn clone(&self) -> LWE<D>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<D: DataRef> Debug for LWE<D>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<D: DataRef> Display for LWE<D>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<D: DataMut> FillUniform for LWE<D>

where Zn<D>: FillUniform,

fn fill_uniform(&mut self, log_bound: usize, source: &mut Source)

impl<D: Data> LWEInfos for LWE<D>

fn base2k(&self) -> Base2K

fn k(&self) -> TorusPrecision

fn n(&self) -> Degree

fn size(&self) -> usize

fn log_n(&self) -> usize

fn max_k(&self) -> TorusPrecision

fn lwe_layout(&self) -> LWELayout

impl<D: DataMut> LWEToMut for LWE<D>

fn to_mut(&mut self) -> LWE<&mut [u8]>

impl<D: DataRef> LWEToRef for LWE<D>

fn to_ref(&self) -> LWE<&[u8]>

impl<D: PartialEq + Data> PartialEq for LWE<D>

fn eq(&self, other: &LWE<D>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<D: DataMut> ReaderFrom for LWE<D>

fn read_from<R: Read>(&mut self, reader: &mut R) -> Result<()>

impl<D: Data> SetLWEInfos for LWE<D>

fn set_base2k(&mut self, base2k: Base2K)

fn set_k(&mut self, k: TorusPrecision)

impl<D: DataRef> WriterTo for LWE<D>

fn write_to<W: Write>(&self, writer: &mut W) -> Result<()>

impl<D: Eq + Data> Eq for LWE<D>

impl<D: Data> StructuralPartialEq for LWE<D>