Struct DynResidue

pub struct DynResidue<const LIMBS: usize> { /* private fields */ }

A residue represented using LIMBS limbs. The odd modulus of this residue is set at runtime.

Implementations

impl<const LIMBS: usize> DynResidue<LIMBS>

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

Adds rhs.

impl<const LIMBS: usize> DynResidue<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<const LIMBS: usize> DynResidue<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<const LIMBS: usize> DynResidue<LIMBS>

pub const fn neg(&self) -> Self

Negates the number.

impl<const LIMBS: usize> DynResidue<LIMBS>

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

Raises to the exponent power.

pub const fn pow_bounded_exp<const RHS_LIMBS: usize>( &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.

NOTE: exponent_bits may be leaked in the time pattern.

impl<const LIMBS: usize> DynResidue<LIMBS>

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

Subtracts rhs.

impl<const LIMBS: usize> DynResidue<LIMBS>

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

Instantiates a new Residue that represents this integer mod MOD.

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

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

pub const fn zero(residue_params: DynResidueParams<LIMBS>) -> Self

Instantiates a new Residue that represents zero.

pub const fn one(residue_params: DynResidueParams<LIMBS>) -> Self

Instantiates a new Residue that represents 1.

pub const fn params(&self) -> &DynResidueParams<LIMBS>

Returns the parameter struct used to initialize this residue.

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

Access the DynResidue value in Montgomery form.

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

Mutably access the DynResidue value in Montgomery form.

pub const fn from_montgomery( integer: Uint<LIMBS>, residue_params: DynResidueParams<LIMBS>, ) -> Self

Create a DynResidue from a value in Montgomery form.

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

Extract the value from the DynResidue 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<const LIMBS: usize> Add<&DynResidue<LIMBS>> for &DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const LIMBS: usize> Add<&DynResidue<LIMBS>> for DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const LIMBS: usize> Add<DynResidue<LIMBS>> for &DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const LIMBS: usize> Add for DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const LIMBS: usize> AddAssign<&DynResidue<LIMBS>> for DynResidue<LIMBS>

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

Performs the += operation.

impl<const LIMBS: usize> AddAssign for DynResidue<LIMBS>

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

Performs the += operation.

impl<const LIMBS: usize> Clone for DynResidue<LIMBS>

fn clone(&self) -> DynResidue<LIMBS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const LIMBS: usize> ConditionallySelectable for DynResidue<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<const LIMBS: usize> ConstantTimeEq for DynResidue<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<const LIMBS: usize> Debug for DynResidue<LIMBS>

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

Formats the value using the given formatter.

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<const LIMBS: usize> Invert for DynResidue<LIMBS>

type Output = CtOption<DynResidue<LIMBS>>

Output of the inversion.

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

Computes the inverse.

impl<const LIMBS: usize> Mul<&DynResidue<LIMBS>> for &DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const LIMBS: usize> Mul<&DynResidue<LIMBS>> for DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const LIMBS: usize> Mul<DynResidue<LIMBS>> for &DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const LIMBS: usize> Mul for DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const LIMBS: usize> MulAssign<&DynResidue<LIMBS>> for DynResidue<LIMBS>

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

Performs the *= operation.

impl<const LIMBS: usize> MulAssign for DynResidue<LIMBS>

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

Performs the *= operation.

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

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

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

impl<const LIMBS: usize> Neg for &DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the - operator.

fn neg(self) -> DynResidue<LIMBS>

Performs the unary - operation.

impl<const LIMBS: usize> Neg for DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<const LIMBS: usize> PartialEq for DynResidue<LIMBS>

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

type Output = Uint<LIMBS>

The original type.

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

Convert the number back from the optimized representation.

impl<const LIMBS: usize> Square for DynResidue<LIMBS>

fn square(&self) -> Self

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

impl<const LIMBS: usize> Sub<&DynResidue<LIMBS>> for &DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const LIMBS: usize> Sub<&DynResidue<LIMBS>> for DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const LIMBS: usize> Sub<DynResidue<LIMBS>> for &DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const LIMBS: usize> Sub for DynResidue<LIMBS>

type Output = DynResidue<LIMBS>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const LIMBS: usize> SubAssign<&DynResidue<LIMBS>> for DynResidue<LIMBS>

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

Performs the -= operation.

impl<const LIMBS: usize> SubAssign for DynResidue<LIMBS>

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

Performs the -= operation.

impl<const LIMBS: usize> Zeroize for DynResidue<LIMBS>

Available on crate feature zeroize only.

NOTE: this does not zeroize the parameters, in order to maintain some form of type consistency

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<const LIMBS: usize> Copy for DynResidue<LIMBS>

impl<const LIMBS: usize> Eq for DynResidue<LIMBS>

impl<const LIMBS: usize> StructuralPartialEq for DynResidue<LIMBS>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.