Struct NttVector 

pub struct NttVector<F: Field, K: ArraySize>(pub Array<NttPolynomial<F>, K>);

An NttVector is a vector of polynomials from T_q of length K.

NTT vectors can be added and subtracted. If multiplication is defined for NTT polynomials, then NTT vectors can be multiplied by NTT polynomials, and “multiplied” with each other to produce a dot product.

Tuple Fields

0: Array<NttPolynomial<F>, K>

Implementations

impl<F: Field, K: ArraySize> NttVector<F, K>

pub const fn new(x: Array<NttPolynomial<F>, K>) -> Self

Create a new NTT vector.

Trait Implementations

impl<F: Field, K: ArraySize> Add<&NttVector<F, K>> for &NttVector<F, K>

type Output = NttVector<F, K>

The resulting type after applying the + operator.

fn add(self, rhs: &NttVector<F, K>) -> NttVector<F, K>

Performs the + operation.

impl<F: Clone + Field, K: Clone + ArraySize> Clone for NttVector<F, K>

fn clone(&self) -> NttVector<F, K>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Field, K: ArraySize> CtEq for NttVector<F, K>

where F::Int: CtEq,

Available on crate feature ctutils only.

fn ct_eq(&self, other: &Self) -> Choice

Determine if self is equal to other in constant-time.

fn ct_ne(&self, other: &Rhs) -> Choice

Determine if self is NOT equal to other in constant-time.

impl<F: Field<Int: CtEq>, K: ArraySize> CtEqSlice for NttVector<F, K>

Available on crate feature ctutils only.

fn ct_eq_slice(a: &[Self], b: &[Self]) -> Choice

Determine if a is equal to b in constant-time.

fn ct_ne_slice(a: &[Self], b: &[Self]) -> Choice

Determine if a is NOT equal to b in constant-time.

impl<F: Debug + Field, K: Debug + ArraySize> Debug for NttVector<F, K>

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

Formats the value using the given formatter.

impl<F: Default + Field, K: Default + ArraySize> Default for NttVector<F, K>

fn default() -> NttVector<F, K>

Returns the “default value” for a type.

impl<F, D, K> Encode<D> for NttVector<F, K>

where F: Field, D: VectorEncodingSize<K>, K: ArraySize,

type EncodedSize = <D as VectorEncodingSize<K>>::EncodedVectorSize

Size of the encoded object.

fn encode(&self) -> Array<u8, Self::EncodedSize>

Encode object.

fn decode(enc: &Array<u8, Self::EncodedSize>) -> Self

Decode object.

impl<F: Field, K: ArraySize> Mul<&NttVector<F, K>> for &NttPolynomial<F>

where for<'a> &'a NttPolynomial<F>: Mul<&'a NttPolynomial<F>, Output = NttPolynomial<F>>,

type Output = NttVector<F, K>

The resulting type after applying the * operator.

fn mul(self, rhs: &NttVector<F, K>) -> NttVector<F, K>

Performs the * operation.

impl<F: Field, K: ArraySize> Mul<&NttVector<F, K>> for &NttVector<F, K>

where for<'a> &'a NttPolynomial<F>: Mul<&'a NttPolynomial<F>, Output = NttPolynomial<F>>,

type Output = NttPolynomial<F>

The resulting type after applying the * operator.

fn mul(self, rhs: &NttVector<F, K>) -> NttPolynomial<F>

Performs the * operation.

impl<F: Field, K: ArraySize, L: ArraySize> Mul<&NttVector<F, L>> for &NttMatrix<F, K, L>

where for<'a> &'a NttPolynomial<F>: Mul<&'a NttPolynomial<F>, Output = NttPolynomial<F>>,

type Output = NttVector<F, K>

The resulting type after applying the * operator.

fn mul(self, rhs: &NttVector<F, L>) -> NttVector<F, K>

Performs the * operation.

impl<F: PartialEq + Field, K: PartialEq + ArraySize> PartialEq for NttVector<F, K>

fn eq(&self, other: &NttVector<F, K>) -> 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<F: Field, K: ArraySize> Sub<&NttVector<F, K>> for &NttVector<F, K>

type Output = NttVector<F, K>

The resulting type after applying the - operator.

fn sub(self, rhs: &NttVector<F, K>) -> NttVector<F, K>

Performs the - operation.

impl<F: Field, K: ArraySize> Zeroize for NttVector<F, K>

where F::Int: Zeroize,

Available on crate feature zeroize only.

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl<F: Eq + Field, K: Eq + ArraySize> Eq for NttVector<F, K>

impl<F: Field, K: ArraySize> StructuralPartialEq for NttVector<F, K>