Struct Residue 

pub struct Residue<MOD, const LIMBS: usize>
where
    MOD: ResidueParams<LIMBS>,
{ /* private fields */ }

A residue mod MOD, represented using LIMBS limbs. The modulus of this residue is constant, so it cannot be set at runtime. Internally, the value is stored in Montgomery form (multiplied by MOD::R) until it is retrieved.

Implementations

impl<MOD, const LIMBS: usize> Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

pub const fn add(&self, rhs: &Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Adds rhs.

impl<MOD, const LIMBS: usize> Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

pub const fn invert(&self) -> (Residue<MOD, LIMBS>, CtChoice)

Computes the residue self^-1 representing the multiplicative inverse of self. I.e. self * self^-1 = 1. If the number was invertible, the second element of the tuple is the truthy value, otherwise it is the falsy value (in which case the first element’s value is unspecified).

impl<MOD, const LIMBS: usize> Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

pub const fn mul(&self, rhs: &Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Multiplies by rhs.

pub const fn square(&self) -> Residue<MOD, LIMBS>

Computes the (reduced) square of a residue.

impl<MOD, const LIMBS: usize> Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

pub const fn neg(&self) -> Residue<MOD, LIMBS>

Negates the number.

impl<MOD, const LIMBS: usize> Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

pub const fn pow<const RHS_LIMBS: usize>( &self, exponent: &Uint<RHS_LIMBS>, ) -> Residue<MOD, LIMBS>

Raises to the exponent power.

pub const fn pow_bounded_exp<const RHS_LIMBS: usize>( &self, exponent: &Uint<RHS_LIMBS>, exponent_bits: usize, ) -> Residue<MOD, LIMBS>

Raises to the exponent power, with exponent_bits representing the number of (least significant) bits to take into account for the exponent.

NOTE: exponent_bits may be leaked in the time pattern.

impl<MOD, const LIMBS: usize> Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

pub const fn sub(&self, rhs: &Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Subtracts rhs.

impl<MOD, const LIMBS: usize> Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

pub const ZERO: Residue<MOD, LIMBS>

The representation of 0 mod MOD.

pub const ONE: Residue<MOD, LIMBS>

The representation of 1 mod MOD.

pub const fn new(integer: &Uint<LIMBS>) -> Residue<MOD, LIMBS>

Instantiates a new Residue that represents this integer mod MOD. If the modulus represented by MOD is not odd, this function will panic; use new_checked if you want to be able to detect an invalid modulus.

pub fn new_checked(integer: &Uint<LIMBS>) -> CtOption<Residue<MOD, LIMBS>>

Instantiates a new Residue that represents this integer mod MOD if the modulus is odd. Returns a CtOption that is None if the provided modulus is not odd; this is a safer version of new, which can panic.

pub const fn retrieve(&self) -> Uint<LIMBS>

Retrieves the integer currently encoded in this Residue, guaranteed to be reduced.

pub const fn as_montgomery(&self) -> &Uint<LIMBS>

Access the Residue value in Montgomery form.

pub fn as_montgomery_mut(&mut self) -> &mut Uint<LIMBS>

Mutably access the Residue value in Montgomery form.

pub const fn from_montgomery(integer: Uint<LIMBS>) -> Residue<MOD, LIMBS>

Create a Residue from a value in Montgomery form.

pub const fn to_montgomery(&self) -> Uint<LIMBS>

Extract the value from the Residue in Montgomery form.

pub fn div_by_2(&self) -> Residue<MOD, LIMBS>

Performs the modular division by 2, that is for given x returns y such that y * 2 = x mod p. This means:

• if x is even, returns x / 2,
• if x is odd, returns (x + p) / 2 (since the modulus p in Montgomery form is always odd, this divides entirely).

Trait Implementations

impl<MOD, const LIMBS: usize> Add<&Residue<MOD, LIMBS>> for &Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the + operator.

fn add(self, rhs: &Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Performs the + operation.

impl<MOD, const LIMBS: usize> Add<&Residue<MOD, LIMBS>> for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the + operator.

fn add(self, rhs: &Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Performs the + operation.

impl<MOD, const LIMBS: usize> Add<Residue<MOD, LIMBS>> for &Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the + operator.

fn add(self, rhs: Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Performs the + operation.

impl<MOD, const LIMBS: usize> Add for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the + operator.

fn add(self, rhs: Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Performs the + operation.

impl<MOD, const LIMBS: usize> AddAssign<&Residue<MOD, LIMBS>> for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

fn add_assign(&mut self, rhs: &Residue<MOD, LIMBS>)

Performs the += operation.

impl<MOD, const LIMBS: usize> AddAssign for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

fn add_assign(&mut self, rhs: Residue<MOD, LIMBS>)

Performs the += operation.

impl<MOD, const LIMBS: usize> Clone for Residue<MOD, LIMBS>

where MOD: Clone + ResidueParams<LIMBS>,

fn clone(&self) -> Residue<MOD, LIMBS>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<MOD, const LIMBS: usize> ConditionallySelectable for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS> + Copy,

fn conditional_select( a: &Residue<MOD, LIMBS>, b: &Residue<MOD, LIMBS>, choice: Choice, ) -> Residue<MOD, LIMBS>

Select a or b according to choice.

fn conditional_assign(&mut self, other: &Self, choice: Choice)

Conditionally assign other to self, according to choice.

fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice)

Conditionally swap self and other if choice == 1; otherwise, reassign both unto themselves.

impl<MOD, const LIMBS: usize> ConstantTimeEq for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

fn ct_eq(&self, other: &Residue<MOD, LIMBS>) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl<MOD, const LIMBS: usize> Debug for Residue<MOD, LIMBS>

where MOD: Debug + ResidueParams<LIMBS>,

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

Formats the value using the given formatter.

impl<MOD, const LIMBS: usize> Default for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

fn default() -> Residue<MOD, LIMBS>

Returns the “default value” for a type.

impl<const LIMBS: usize, P> From<&Residue<P, LIMBS>> for DynResidue<LIMBS>

where P: ResidueParams<LIMBS>,

fn from(residue: &Residue<P, LIMBS>) -> DynResidue<LIMBS>

Converts to this type from the input type.

impl<MOD, const LIMBS: usize> Invert for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = CtOption<Residue<MOD, LIMBS>>

Output of the inversion.

fn invert(&self) -> <Residue<MOD, LIMBS> as Invert>::Output

Computes the inverse.

impl<MOD, const LIMBS: usize> Mul<&Residue<MOD, LIMBS>> for &Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: &Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Performs the * operation.

impl<MOD, const LIMBS: usize> Mul<&Residue<MOD, LIMBS>> for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: &Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Performs the * operation.

impl<MOD, const LIMBS: usize> Mul<Residue<MOD, LIMBS>> for &Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Performs the * operation.

impl<MOD, const LIMBS: usize> Mul for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Performs the * operation.

impl<MOD, const LIMBS: usize> MulAssign<&Residue<MOD, LIMBS>> for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

fn mul_assign(&mut self, rhs: &Residue<MOD, LIMBS>)

Performs the *= operation.

impl<MOD, const LIMBS: usize> MulAssign for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

fn mul_assign(&mut self, rhs: Residue<MOD, LIMBS>)

Performs the *= operation.

impl<const N: usize, MOD, const LIMBS: usize, const RHS_LIMBS: usize> MultiExponentiateBoundedExp<Uint<RHS_LIMBS>, [(Residue<MOD, LIMBS>, Uint<RHS_LIMBS>); N]> for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

fn multi_exponentiate_bounded_exp( bases_and_exponents: &[(Residue<MOD, LIMBS>, Uint<RHS_LIMBS>); N], exponent_bits: usize, ) -> Residue<MOD, LIMBS>

Calculates x1 ^ k1 * ... * xn ^ kn.

impl<MOD, const LIMBS: usize> Neg for &Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the - operator.

fn neg(self) -> Residue<MOD, LIMBS>

Performs the unary - operation.

impl<MOD, const LIMBS: usize> Neg for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the - operator.

fn neg(self) -> Residue<MOD, LIMBS>

Performs the unary - operation.

impl<MOD, const LIMBS: usize> PartialEq for Residue<MOD, LIMBS>

where MOD: PartialEq + ResidueParams<LIMBS>,

fn eq(&self, other: &Residue<MOD, LIMBS>) -> 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<MOD, const LIMBS: usize, const RHS_LIMBS: usize> PowBoundedExp<Uint<RHS_LIMBS>> for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

fn pow_bounded_exp( &self, exponent: &Uint<RHS_LIMBS>, exponent_bits: usize, ) -> Residue<MOD, LIMBS>

Raises to the exponent power, with exponent_bits representing the number of (least significant) bits to take into account for the exponent.

impl<MOD, const LIMBS: usize> Random for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

Available on crate feature rand_core only.

fn random(rng: &mut impl CryptoRngCore) -> Residue<MOD, LIMBS>

Generate a cryptographically secure random value.

impl<MOD, const LIMBS: usize> Retrieve for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Uint<LIMBS>

The original type.

fn retrieve(&self) -> <Residue<MOD, LIMBS> as Retrieve>::Output

Convert the number back from the optimized representation.

impl<MOD, const LIMBS: usize> Square for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

fn square(&self) -> Residue<MOD, LIMBS>

Computes the same as self.mul(self), but may be more efficient.

impl<MOD, const LIMBS: usize> Sub<&Residue<MOD, LIMBS>> for &Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the - operator.

fn sub(self, rhs: &Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Performs the - operation.

impl<MOD, const LIMBS: usize> Sub<&Residue<MOD, LIMBS>> for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the - operator.

fn sub(self, rhs: &Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Performs the - operation.

impl<MOD, const LIMBS: usize> Sub<Residue<MOD, LIMBS>> for &Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the - operator.

fn sub(self, rhs: Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Performs the - operation.

impl<MOD, const LIMBS: usize> Sub for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

type Output = Residue<MOD, LIMBS>

The resulting type after applying the - operator.

fn sub(self, rhs: Residue<MOD, LIMBS>) -> Residue<MOD, LIMBS>

Performs the - operation.

impl<MOD, const LIMBS: usize> SubAssign<&Residue<MOD, LIMBS>> for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

fn sub_assign(&mut self, rhs: &Residue<MOD, LIMBS>)

Performs the -= operation.

impl<MOD, const LIMBS: usize> SubAssign for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

fn sub_assign(&mut self, rhs: Residue<MOD, LIMBS>)

Performs the -= operation.

impl<MOD, const LIMBS: usize> Zero for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

const ZERO: Residue<MOD, LIMBS> = Self::ZERO

The value 0.

fn is_zero(&self) -> Choice

Determine if this value is equal to zero.

impl<MOD, const LIMBS: usize> Copy for Residue<MOD, LIMBS>

where MOD: Copy + ResidueParams<LIMBS>,

impl<MOD, const LIMBS: usize> DefaultIsZeroes for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,

Available on crate feature zeroize only.

impl<MOD, const LIMBS: usize> Eq for Residue<MOD, LIMBS>

where MOD: Eq + ResidueParams<LIMBS>,

impl<MOD, const LIMBS: usize> StructuralPartialEq for Residue<MOD, LIMBS>

where MOD: ResidueParams<LIMBS>,