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: ResidueParams<LIMBS>, const LIMBS: usize> Residue<MOD, LIMBS>

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

Adds rhs.

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

pub const fn invert(&self) -> (Self, 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: ResidueParams<LIMBS>, const LIMBS: usize> Residue<MOD, LIMBS>

pub const fn mul(&self, rhs: &Self) -> Self

Multiplies by rhs.

pub const fn square(&self) -> Self

Computes the (reduced) square of a residue.

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

pub const fn neg(&self) -> Self

Negates the number.

impl<MOD: ResidueParams<LIMBS>, const LIMBS: usize> Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> Residue<MOD, LIMBS>

pub const fn sub(&self, rhs: &Self) -> Self

Subtracts rhs.

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

pub const ZERO: Self

The representation of 0 mod MOD.

pub const ONE: Self

The representation of 1 mod MOD.

pub const fn new(integer: &Uint<LIMBS>) -> Self

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<Self>

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>) -> Self

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) -> Self

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: ResidueParams<LIMBS>, const LIMBS: usize> Add<&Residue<MOD, LIMBS>> for &Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> Add<&Residue<MOD, LIMBS>> for Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> Add<Residue<MOD, LIMBS>> for &Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> Add for Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> AddAssign<&Residue<MOD, LIMBS>> for Residue<MOD, LIMBS>

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

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

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

where MOD: ResidueParams<LIMBS> + Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self

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: ResidueParams<LIMBS>, const LIMBS: usize> ConstantTimeEq for Residue<MOD, LIMBS>

fn ct_eq(&self, other: &Self) -> 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: ResidueParams<LIMBS> + Debug,

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

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

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

Converts to this type from the input type.

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

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

Output of the inversion.

fn invert(&self) -> Self::Output

Computes the inverse.

impl<MOD: ResidueParams<LIMBS>, const LIMBS: usize> Mul<&Residue<MOD, LIMBS>> for &Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> Mul<&Residue<MOD, LIMBS>> for Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> Mul<Residue<MOD, LIMBS>> for &Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> Mul for Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> MulAssign<&Residue<MOD, LIMBS>> for Residue<MOD, LIMBS>

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

Performs the *= operation.

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

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

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

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

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

impl<MOD: ResidueParams<LIMBS>, const LIMBS: usize> Neg for &Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> Neg for Residue<MOD, LIMBS>

type Output = Residue<MOD, LIMBS>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

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

where MOD: ResidueParams<LIMBS> + PartialEq,

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: ResidueParams<LIMBS>, const LIMBS: usize, const RHS_LIMBS: usize> PowBoundedExp<Uint<RHS_LIMBS>> for Residue<MOD, LIMBS>

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

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>,

fn random(rng: &mut impl CryptoRngCore) -> Self

Generate a cryptographically secure random value.

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

type Output = Uint<LIMBS>

The original type.

fn retrieve(&self) -> Self::Output

Convert the number back from the optimized representation.

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

fn square(&self) -> Self

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

impl<MOD: ResidueParams<LIMBS>, const LIMBS: usize> Sub<&Residue<MOD, LIMBS>> for &Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> Sub<&Residue<MOD, LIMBS>> for Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> Sub<Residue<MOD, LIMBS>> for &Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> Sub for Residue<MOD, 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: ResidueParams<LIMBS>, const LIMBS: usize> SubAssign<&Residue<MOD, LIMBS>> for Residue<MOD, LIMBS>

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

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

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

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

const ZERO: Self = 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: ResidueParams<LIMBS> + Copy,

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

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

where MOD: ResidueParams<LIMBS> + Eq,

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

where MOD: ResidueParams<LIMBS>,