Struct Poly 

pub struct Poly {
    pub coeffs: [FieldElement; 256],
}

Polynomial in the time (coefficient) domain, canonical representatives mod q.

Fields

coeffs: [FieldElement; 256]

Coefficients c[0] + c[1] X + … + c[255] X^{255}.

Implementations

impl Poly

pub const fn zero() -> Self

Zero polynomial.

pub const fn from_coeffs(coeffs: [FieldElement; 256]) -> Self

Construct from canonical coefficients (already reduced mod q is recommended).

pub fn add_assign(&mut self, rhs: &Self)

Coefficient-wise addition mod q (Barrett reduction).

pub fn sub_assign(&mut self, rhs: &Self)

Coefficient-wise subtraction mod q.

pub fn scalar_mul_assign(&mut self, k: i32)

Multiply every coefficient by a small integer, then reduce mod q.

pub fn mul_negacyclic(&self, rhs: &Self) -> Self

Negacyclic convolution mod (X^256 + 1) via schoolbook (O(n^2)) (test / reference).

pub fn infinity_norm(&self) -> i32

Infinity norm on absolute representatives in ([-q/2, q/2])-style range.

Branch-free over coefficient values (ML-DSA portable infinity_norm_exceeds model): leaking which coefficient exceeds a bound is acceptable on verify paths; the sign of the centered representative must not leak via control flow.

pub fn norm_within_bound(&self, bound: i32) -> Choice

Returns 1 iff Self::infinity_norm is at most bound (inclusive).

pub fn normalize_mod_q_assign(&mut self)

Map every coefficient into canonical [0, q) via Barrett reduction, then branch-free non-negative fixup: v + ((v >> 31) & q).

pub fn scalar_mul_by_u32_mod_q(&self, scalar: u32) -> Poly

Multiply every coefficient by scalar (mod q) using wide multiply + Barrett reduction.

pub fn to_simd(&self) -> [Coefficients; 32]

SIMD lane layout (ML-DSA coefficient order).

pub fn to_ntt(&self) -> NttPoly

Map to the NTT/Montgomery SIMD representation used by ML-DSA.

Trait Implementations

impl Clone for Poly

fn clone(&self) -> Poly

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Poly

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

Formats the value using the given formatter.

impl Drop for Poly

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 Hash for Poly

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Poly

fn eq(&self, other: &Poly) -> 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 Zeroize for Poly

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 Eq for Poly

impl StructuralPartialEq for Poly