Struct rsa_cortex_m4::arithmetic::Wrapping

#[repr(transparent)]pub struct Wrapping<T>(pub T);

Intentionally-wrapped arithmetic.

We can't use core::num::Wrapping due to type coherence clashing with our usage requirements.

The idea is that T is [Number], and we wrap around $2^N$ where N = T::BITS.

Implementations

impl<const D: usize, const E: usize> Wrapping<Unsigned<D, E>>

pub fn inv(&self) -> Result<Self>

See Unsigned::wrapping_inv.

Trait Implementations

impl<const D: usize, const E: usize> Add<&'_ Wrapping<Unsigned<D, E>>> for &Wrapping<Unsigned<D, E>>

type Output = Wrapping<Unsigned<D, E>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const D: usize, const E: usize> AddAssign<&'_ Wrapping<Unsigned<D, E>>> for Wrapping<Unsigned<D, E>>

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

Performs the += operation.

impl<T: Clone> Clone for Wrapping<T>

fn clone(&self) -> Wrapping<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Wrapping<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Wrapping<T>

fn default() -> Wrapping<T>

Returns the "default value" for a type.

impl<T: Number> Deref for Wrapping<T>

type Target = [Digit]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Number + NumberMut> DerefMut for Wrapping<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<const D: usize, const E: usize> Mul<&'_ Wrapping<Unsigned<D, E>>> for &Wrapping<Unsigned<D, E>>

type Output = Wrapping<Unsigned<D, E>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const D: usize, const E: usize> Neg for &Wrapping<Unsigned<D, E>>

type Output = Wrapping<Unsigned<D, E>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Number> Number for Wrapping<T>

const BITS: usize

The number of bits that fit in this number.

const DIGITS: usize

The number of digits that fit in this number.

fn significant_digits(&self) -> &[Digit]

The significant digits of the number (little-endian).

fn leading_digit(&self) -> Option<Digit>

The last non-zero digit of the number.

fn to_unsigned<const D: usize, const E: usize>(&self) -> Result<Unsigned<D, E>>

Embed in number with D + E digits, if possible.

fn zero() -> Self

fn is_zero(&self) -> bool

fn is_one(&self) -> bool

fn is_digit(&self) -> bool

fn is_odd(&self) -> bool

fn cmp(&self, other: &impl Number) -> Ordering

This is little endian ordering, as opposed to the default ordering on arrays and slices!

fn eq(&self, other: &impl Number) -> bool

fn deref(&self) -> &[Digit]

fn deref_mut(&mut self) -> &mut Self::Target

impl<T: Number + NumberMut> NumberMut for Wrapping<T>

fn from_slice(slice: &[Digit]) -> Self

fn try_from_slice(slice: &[Digit]) -> Result<Self>

fn from_bytes(bytes: &[u8]) -> Self

fn set_zero(&mut self)

fn one() -> Self

fn swap_order(self) -> Self

Swap endianness of digits in Self and, if the platform is little-endian, endianness of bytes within digits.

fn random(rng: impl CryptoRng + RngCore) -> Self

impl<T: PartialEq> PartialEq<Wrapping<T>> for Wrapping<T>

fn eq(&self, other: &Wrapping<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Wrapping<T>) -> bool

This method tests for !=.

impl<T> RefCast for Wrapping<T>

type From = T

fn ref_cast(_from: &Self::From) -> &Self

fn ref_cast_mut(_from: &mut Self::From) -> &mut Self

impl<T> StructuralPartialEq for Wrapping<T>

impl<const D: usize, const E: usize, const L: usize> Sub<&'_ Wrapping<Array<D, E, L>>> for &Wrapping<Array<D, E, L>>

type Output = Wrapping<Array<D, E, L>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const D: usize, const E: usize> Sub<&'_ Wrapping<Unsigned<D, E>>> for &Wrapping<Unsigned<D, E>>

type Output = Wrapping<Unsigned<D, E>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const D: usize, const E: usize> SubAssign<&'_ T> for Wrapping<Unsigned<D, E>> where
    T: Number, 

TODO: This implementation (and the analogous one for Array) needs to be properly tested/fuzzed.

It's implemented more generally than for just T = Unsigned<D, E> as we need that in `crate::arithmetic::divide::generic_div_rem.

There, we want to implement for any (dividend, divisor) pair. The only real work is done for dividend > divisor, implying that dividend.len() >= divisor.len(), and, where we're called, minuend >= subtrahend, and hence minuend.len() >= subtrahend.len().

This is needed to make the implementation of sub_assign_borrow (with dropped borrow) valid.

fn sub_assign(&mut self, subtrahend: &T)

Performs the -= operation.

impl<T, const D: usize, const E: usize, const L: usize> SubAssign<&'_ T> for Wrapping<Array<D, E, L>> where
    T: Number, 

TODO: See remark about SubAssign for Unsigned<D, E>

fn sub_assign(&mut self, other: &T)

Performs the -= operation.