Struct cryptix_field::field::primefield::FpElement

pub struct FpElement<I, M: PrimeModular<I>>(pub Element<I, M>);

Element in field F_p

Tuple Fields

0: Element<I, M>

Implementations

impl<I, M: PrimeModular<I>> FpElement<I, M>

pub fn new_unchecked(value: I) -> Self

Safety

The safey is the same as Element::new_unchecked

impl<I: Copy, M: PrimeModular<I>> FpElement<I, M>

pub fn repr(self) -> I

Trait Implementations

impl<I, M> Add<FpElement<I, M>> for FpElement<I, M>where M: PrimeModular<I>, I: BigIntOps,

type Output = FpElement<I, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<I, M> AddIdentity for FpElement<I, M>where M: PrimeModular<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: PrimeModular<I>> Clone for FpElement<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: PrimeModular<I>> Debug for FpElement<I, M>

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

Formats the value using the given formatter.

impl<I, M> Field for FpElement<I, M>where I: BigIntOpsExt, M: Montgomery<I>,

fn hlv(self) -> Self

calculate self / 2 in field

fn is_zero(&self) -> bool

check if self is zero

impl<I: IsBigInt, M: PrimeModular<I>> From<FpElement<I, M>> for [u8; I::BYTE_LEN]

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

Converts to this type from the input type.

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: PrimeModular<I>> From<I> for FpElement<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> MontgomeryOps<I, M> for FpElement<I, M>where I: BigIntOpsExt, M: Montgomery<I>,

fn mont_mul(self, rhs: Self) -> Self

lhs * rhs * R^(-1) mod P

fn mont_rdc(self) -> Self

a * R^(-1) mod P

fn mont_inv(self) -> Self

input: aoutput: a^(-1) * RR mod P

fn mont_mul_fp(self, rhs: FpElement<I, M>) -> Self

fn mont_sqr(self) -> Self

a^2 * R^(-1) mod P

fn mont_form(self) -> Self

a * R mod P

fn mont_exp(self, exp: I) -> Self

base^exp mod P

impl<I, M> Mul<FpElement<I, M>> for FpElement<I, M>where M: Montgomery<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 = FpElement<I, M>

The resulting type after applying the * operator.

impl<I, M> MulIdentity for FpElement<I, M>where I: BigIntOpsExt + IsBigInt, M: Montgomery<I>,

Safety

1 is the multiplicative ideneity for biguint

const MUL_IDENTITY: Self = _

const ONE: Self = Self::MUL_IDENTITY

impl<I, M> MulInverse for FpElement<I, M>where I: BigIntOpsExt, M: Montgomery<I>,

The montgomery trait bound restricts the modular to odd prime

fn mul_inv(self) -> Self

impl<I, M> Neg for FpElement<I, M>where M: PrimeModular<I>, I: BigIntOps,

type Output = FpElement<I, M>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<I: Ord, M: Ord + PrimeModular<I>> Ord for FpElement<I, M>

fn cmp(&self, other: &FpElement<I, M>) -> 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: PartialEq + PrimeModular<I>> PartialEq<FpElement<I, M>> for FpElement<I, M>

fn eq(&self, other: &FpElement<I, M>) -> 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: PartialOrd + PrimeModular<I>> PartialOrd<FpElement<I, M>> for FpElement<I, M>

fn partial_cmp(&self, other: &FpElement<I, M>) -> 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<FpElement<I, M>> for FpElement<I, M>where M: PrimeModular<I>, I: BigIntOps,

type Output = FpElement<I, M>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<I, M> AbelianGroup for FpElement<I, M>where M: PrimeModular<I>, Self: Group + CommunicativeAdd,

impl<I, M> AssociativeAdd for FpElement<I, M>where M: PrimeModular<I>, Self: Add<Output = Self>,

Safety

Element is backed by biguint, which is associative under addition

impl<I, M> AssociativeMul for FpElement<I, M>where M: Montgomery<I>, I: BigIntOpsExt,

Safety

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

impl<I, M> CommunicativeAdd for FpElement<I, M>where M: PrimeModular<I>, Self: Add<Output = Self>,

Safety

Element is backed by biguint, which is communicative under addition

impl<I, M> CommunicativeMul for FpElement<I, M>where M: Montgomery<I>, I: BigIntOpsExt,

Safety

BigUInt mod mul is communicative

impl<I: Copy, M: PrimeModular<I>> Copy for FpElement<I, M>

impl<I, M> DistributiveMul for FpElement<I, M>where M: Montgomery<I>, I: BigIntOpsExt,

Safety

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

impl<I: Eq, M: Eq + PrimeModular<I>> Eq for FpElement<I, M>

impl<I, M> Group for FpElement<I, M>where M: PrimeModular<I>, I: BigIntOps,

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

impl<I, M: PrimeModular<I>> StructuralEq for FpElement<I, M>

impl<I, M: PrimeModular<I>> StructuralPartialEq for FpElement<I, M>