Struct rsa_cortex_m4::arithmetic::Modular

pub struct Modular<'n, const D: usize, const E: usize> { /* fields omitted */ }

Modular integer, corresponds to the residue class "modulo modulus".

For fixed modulus, this is a ring. If the modulus is prime, this is a field.

All constructors must enforce that x < n is the canonical residue class representative.

TODO: Maybe x and n don't need to have the same size. E.g., would like to express x mod 2**{32*L}. But nothing actually larger than this.

On the other hand, if n is substantially smaller (e.g., e, which has L = 1), then it would be nice to project x down to that size.

Implementations

impl<'n, const D: usize, const E: usize> Modular<'n, D, E>

pub fn zero(n: &'n Convenient<D, E>) -> Self

pub fn digit_pow(&self, _exponent: Digit) -> Self

pub fn canonical_lift(&self) -> Unsigned<D, E>

The canonical representative of this residue class.

This is like [lift][lift] in GP/PARI

By virtue of our moduli's convenience, this is just a conditional subtraction. [lift]: https://pari.math.u-bordeaux.fr/dochtml/html/Conversions_and_similar_elementary_functions_or_commands.html#se:lift

pub fn residue(&self) -> &Unsigned<D, E>

Or non-canonical lift

pub fn to_montgomery(&self) -> Montgomery<'n, D, E>

pub fn power<const F: usize, const G: usize>(
    &self,
    exponent: &Unsigned<F, G>
) -> Self

Trait Implementations

impl<'a, 'n, const D: usize, const E: usize> Add<&'a Modular<'n, D, E>> for &'a Modular<'n, D, E>

type Output = Modular<'n, D, E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b, const D: usize, const E: usize, const F: usize, const G: usize> Add<&'b Unsigned<F, G>> for Modular<'a, D, E>

type Output = Self

The resulting type after applying the + operator.

fn add(self, summand: &'b Unsigned<F, G>) -> Self::Output

Performs the + operation.

impl<'a, 'n, const D: usize, const E: usize> AddAssign<&'a Modular<'n, D, E>> for Modular<'n, D, E>

fn add_assign(&mut self, summand: &'a Self)

Performs the += operation.

impl<'a, 'b, const D: usize, const E: usize, const F: usize, const G: usize> AddAssign<&'b Unsigned<F, G>> for Modular<'a, D, E>

fn add_assign(&mut self, summand: &'b Unsigned<F, G>)

Performs the += operation.

impl<const D: usize, const E: usize> Bits for Modular<'_, D, E>

const BITS: usize

impl<'n, const D: usize, const E: usize> Clone for Modular<'n, D, E>

fn clone(&self) -> Modular<'n, D, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'n, const D: usize, const E: usize> Debug for Modular<'n, D, E>

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

Formats the value using the given formatter.

impl<const D: usize, const E: usize> From<Modular<'_, D, E>> for Unsigned<D, E>

fn from(class: Modular<'_, D, E>) -> Self

Performs the conversion.

impl<'l, 'n, const D: usize, const E: usize> Mul<&'l Modular<'n, D, E>> for &'l Modular<'n, D, E>

Currently see no way of ensuring that both factors have the same modulus on a type level; hence a runtime debug_assert instead.

type Output = Modular<'n, D, E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'n, const D: usize, const E: usize> Neg for &Modular<'n, D, E>

type Output = Modular<'n, D, E>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, 'n, const D: usize, const E: usize> Sub<&'a Modular<'n, D, E>> for &'a Modular<'n, D, E>

type Output = Modular<'n, D, E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b, const D: usize, const E: usize, const F: usize, const G: usize> Sub<&'b Unsigned<F, G>> for Modular<'a, D, E>

type Output = Self

The resulting type after applying the - operator.

fn sub(self, subtrahend: &'b Unsigned<F, G>) -> Self::Output

Performs the - operation.

impl<'a, 'n, const D: usize, const E: usize> SubAssign<&'a Modular<'n, D, E>> for Modular<'n, D, E>

fn sub_assign(&mut self, subtrahend: &'a Self)

Performs the -= operation.

impl<'a, 'b, const D: usize, const E: usize, const F: usize, const G: usize> SubAssign<&'b Unsigned<F, G>> for Modular<'a, D, E>

fn sub_assign(&mut self, subtrahend: &'b Unsigned<F, G>)

Performs the -= operation.

impl<const D: usize, const E: usize> Zeroize for Modular<'_, D, E>

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.