Struct ModuleElement

pub struct ModuleElement<const N: usize> { /* private fields */ }

The Module is a matrix over the cyclotomic ring (i.e., the ring of residue classes of polynomials modulo X^64+1). The matrix contains N cyclotomic ring elements in total.

Implementations

impl<const N: usize> ModuleElement<N>

pub fn sample_short(randomness: &[u8]) -> Self

pub fn sample_uniform(randomness: &[u8]) -> Self

pub fn ntt(&self) -> Self

pub fn intt(&self) -> Self

pub fn multiply_hadamard<const LHS_H: usize, const LHS_N: usize, const RHS_W: usize, const RHS_N: usize, const INNER: usize, const OUT_N: usize>( lhs: ModuleElement<LHS_N>, rhs: ModuleElement<RHS_N>, ) -> ModuleElement<OUT_N>

Multiply two module elements from a pair of matrix- multiplication-compatible modules. This method uses hadamard multiplication for cyclotomic ring elements, which is useful for avoiding the repeated conversion to and from NTT domain.

• N counts the total number of elements in the matrix;
• H counts the number of rows of the left hand side (and of the output) matrix;
• W counts the number of columns of the right hand side (and of the output) matrix;
• INNER counts the number of columns of the left hand side, as well as the number of rows of the right hand side.

pub fn multiply<const LHS_H: usize, const LHS_N: usize, const RHS_W: usize, const RHS_N: usize, const INNER: usize, const OUT_N: usize>( lhs: ModuleElement<LHS_N>, rhs: ModuleElement<RHS_N>, ) -> ModuleElement<OUT_N>

Multiply two module elements from a pair of matrix- multiplication-compatible modules. This method uses the multiplication defined for cyclotomic ring elements abstractly. For a faster method that computes the entire matrix multiplication in the NTT domain, use fast_multiply.

• N counts the total number of elements in the matrix;
• H counts the number of rows of the left hand side (and of the output) matrix;
• W counts the number of columns of the right hand side (and of the output) matrix;
• INNER counts the number of columns of the left hand side, as well as the number of rows of the right hand side.

pub fn fast_multiply<const LHS_H: usize, const LHS_N: usize, const RHS_W: usize, const RHS_N: usize, const INNER: usize, const OUT_N: usize>( lhs: ModuleElement<LHS_N>, rhs: ModuleElement<RHS_N>, ) -> ModuleElement<OUT_N>

Multiply two module elements from a pair of matrix- multiplication-compatible modules, by converting everything into the NTT domain, performing the matrix multiplication, and converting back.

• N counts the total number of elements in the matrix;
• H counts the number of rows of the left hand side (and of the output) matrix;
• W counts the number of columns of the right hand side (and of the output) matrix;
• INNER counts the number of columns of the left hand side, as well as the number of rows of the right hand side.

Trait Implementations

impl<const N: usize> Add for ModuleElement<N>

type Output = ModuleElement<N>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const N: usize> Clone for ModuleElement<N>

fn clone(&self) -> ModuleElement<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for ModuleElement<N>

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

Formats the value using the given formatter.

impl<'de, const N: usize> Deserialize<'de> for ModuleElement<N>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize> PartialEq for ModuleElement<N>

fn eq(&self, other: &ModuleElement<N>) -> 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<const N: usize> Serialize for ModuleElement<N>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: usize> Sub for ModuleElement<N>

type Output = ModuleElement<N>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const N: usize> Zero for ModuleElement<N>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<const N: usize> Copy for ModuleElement<N>

impl<const N: usize> Eq for ModuleElement<N>

impl<const N: usize> StructuralPartialEq for ModuleElement<N>