Struct cryptix_field::Element

pub struct Element<I, M: Modular<I>>(pub I, _);

An element in mod n ring, the type parameter I should be an integer the modular p is embedded in the type parameter M, it’s typically a ZST

Tuple Fields

0: I

Implementations

impl<I, M: Modular<I>> Element<I, M>where I: Rem<Output = I>,

pub fn new(value: I) -> Self

impl<I, M: Modular<I>> Element<I, M>

pub const fn new_unchecked(value: I) -> Self

Safety

This function is designed to be used in const environment to directly convert a canonical representative into mod p field element. So we made an assumption that the parameter value must lie between 0 to p - 1. Creating a field element with non-canonical representative can lead to unexpected result when computing

impl<I, M: Modular<I>> Element<I, M>

pub const fn repr(&self) -> &I

value of the representative

pub const fn modular() -> I

Trait Implementations

impl<I, M> Add<Element<I, M>> for Element<I, M>where M: Modular<I>, I: BigIntOps,

type Output = Element<I, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<I, M> AddIdentity for Element<I, M>where M: Modular<I>, I: BigIntOps + IsBigInt,

const ADD_IDENTITY: Self = _

the identity of mod add operation, typically zero

const ZERO: Self = Self::ADD_IDENTITY

impl<I: Copy, M: Modular<I>> Clone for Element<I, M>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug, M: Modular<I>> Debug for Element<I, M>

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

Formats the value using the given formatter.

impl<I, M: PrimeModular<I>> From<FpElement<I, M>> for Element<I, M>

fn from(value: FpElement<I, M>) -> Self

Converts to this type from the input type.

impl<I, M: Modular<I>> From<I> for Element<I, M>where I: Rem<Output = I>,

fn from(value: I) -> Self

convert a integer to a mod p field element, this value will be converted into the canonical representative

impl<I, M> Mul<Element<I, M>> for Element<I, M>where M: Modular<I>, I: BigIntOpsExt,

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

calculate a * b mod m this can be achieved more efficiently with montgomery multiplication

type Output = Element<I, M>

The resulting type after applying the * operator.

impl<I, M> Neg for Element<I, M>where M: Modular<I>, Self: Sub<Output = Self> + AddIdentity,

type Output = Element<I, M>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<I: Ord, M: Modular<I>> Ord for Element<I, M>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<I: PartialEq, M: Modular<I>> PartialEq<Element<I, M>> for Element<I, M>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I: PartialOrd, M: Modular<I>> PartialOrd<Element<I, M>> for Element<I, M>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<I, M> Sub<Element<I, M>> for Element<I, M>where M: Modular<I>, I: BigIntOps,

type Output = Element<I, M>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<I, M> AbelianGroup for Element<I, M>where M: Modular<I>, Self: Group + CommunicativeAdd,

impl<I, M> AssociativeAdd for Element<I, M>where M: Modular<I>, Self: Add<Output = Self>,

Safety

Element is backed by biguint, which is associative under addition

impl<I, M> AssociativeMul for Element<I, M>where M: Modular<I>, Self: Mul<Output = Self>,

Safety

our element type is backed by biguint, so mod mul is associative

impl<I, M> CommunicativeAdd for Element<I, M>where M: Modular<I>, Self: Add<Output = Self>,

Safety

Element is backed by biguint, which is communicative under addition

impl<I: Copy, M: Modular<I>> Copy for Element<I, M>

impl<I, M> DistributiveMul for Element<I, M>where M: Modular<I>, Self: Mul<Output = Self> + Add<Output = Self>,

Safety

our element type is backed by biguint, so mod mul is distributive over add

impl<I: Eq, M: Modular<I>> Eq for Element<I, M>

impl<I, M> Group for Element<I, M>where M: Modular<I>, I: BigIntOps,

impl<I, M> Ring for Element<I, M>where M: Modular<I>, Self: Mul<Output = Self> + AssociativeMul + DistributiveMul + AbelianGroup,