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

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

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.