Struct Elem 

pub struct Elem<F: Field>(pub F::Int);

An Elem is a member of the specified prime-order field.

Elements can be added, subtracted, multiplied, and negated, and the overloaded operators will ensure both that the integer values remain in the field, and that the reductions are done efficiently.

For addition and subtraction, a simple conditional subtraction is used; for multiplication, Barrett reduction.

Tuple Fields

0: F::Int

Implementations

impl<F: Field> Elem<F>

pub const fn new(x: F::Int) -> Self

Create a new field element.

Trait Implementations

impl<F: Field> Add for Elem<F>

type Output = Elem<F>

The resulting type after applying the + operator.

fn add(self, rhs: Elem<F>) -> Elem<F>

Performs the + operation.

impl<F: Clone + Field> Clone for Elem<F>

where F::Int: Clone,

fn clone(&self) -> Elem<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Field> CtEq for Elem<F>

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>> CtEqSlice for Elem<F>

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> Debug for Elem<F>

where F::Int: Debug,

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

Formats the value using the given formatter.

impl<F: Default + Field> Default for Elem<F>

where F::Int: Default,

fn default() -> Elem<F>

Returns the “default value” for a type.

impl<F: Field> Mul<&NttPolynomial<F>> for Elem<F>

type Output = NttPolynomial<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Field> Mul<&Polynomial<F>> for Elem<F>

type Output = Polynomial<F>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Vector<F, K>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Field> Mul for Elem<F>

type Output = Elem<F>

The resulting type after applying the * operator.

fn mul(self, rhs: Elem<F>) -> Elem<F>

Performs the * operation.

impl<F: Field> Neg for Elem<F>

type Output = Elem<F>

The resulting type after applying the - operator.

fn neg(self) -> Elem<F>

Performs the unary - operation.

impl<F: PartialEq + Field> PartialEq for Elem<F>

where F::Int: PartialEq,

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

type Output = Elem<F>

The resulting type after applying the - operator.

fn sub(self, rhs: Elem<F>) -> Elem<F>

Performs the - operation.

impl<F: Field> Zeroize for Elem<F>

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: Copy + Field> Copy for Elem<F>

where F::Int: Copy,

impl<F: Eq + Field> Eq for Elem<F>

where F::Int: Eq,

impl<F: Field> StructuralPartialEq for Elem<F>