Struct modtype::non_static::ModType

pub struct ModType<C: Cartridge> { /* fields omitted */ }

A modular arithmetic integer type which modulus is a struct field.

Example

#[allow(non_snake_case)]
let F = modtype::non_static::F::factory(1_000_000_007u64);

assert_eq!((F(1_000_000_006) + F(2)).to_string(), "1");

Methods

impl<T: UnsignedPrimitive, C: Cartridge<Target = T>> ModType<C>

pub fn new(value: T, modulus: T) -> Self

Constructs a new ModType.

pub fn new_unchecked(value: T, modulus: T) -> Self

Constructs a new ModType without checking the value.

pub fn factory(modulus: T) -> impl Fn(T) -> Self

Same as move |n| Self::new(n, modulus).

pub fn get_mut_unchecked(&mut self) -> &mut T

Returns a mutable reference to the inner value.

pub fn adjust(&mut self) where
    C: Cartridge<AssumeAlwaysAdjusted = False>, 

pub fn adjusted(self) -> Self where
    C: Cartridge<AssumeAlwaysAdjusted = False>, 

pub fn modulus(self) -> T

Gets the modulus.

pub fn sqrt(self) -> Option<Self> where
    C: Cartridge<PartialMultiplication = True>, 

Returns r such that r * r == self if it exists.

Trait Implementations

impl<C: Cartridge> PartialEq<ModType<C>> for ModType<C> where
    C: Cartridge<Equality = True>, 

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

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<C: Cartridge> Clone for ModType<C>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Cartridge> PartialOrd<ModType<C>> for ModType<C> where
    C: Cartridge<Equality = True, Order = True>, 

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<C: Cartridge> Eq for ModType<C> where
    C: Cartridge<Equality = True>, 

impl<C: Cartridge> Ord for ModType<C> where
    C: Cartridge<Equality = True, Order = True>, 

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<C: Cartridge> Copy for ModType<C>

impl<C: Cartridge> Deref for ModType<C> where
    C: Cartridge<Deref = True>, 

type Target = C::Target

The resulting type after dereferencing.

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

Dereferences the value.

impl<C: Cartridge> Display for ModType<C>

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<C: Cartridge> Debug for ModType<C>

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<C: Cartridge> Add<ModType<C>> for ModType<C> where
    C: Cartridge<PartialAddition = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: ModType<C>) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ ModType<C>> for ModType<C> where
    C: Cartridge<PartialAddition = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &ModType<C>) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<ModType<C>> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: ModType<C>) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ ModType<C>> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &ModType<C>) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<u8> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ u8> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<u8> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ u8> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<u16> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ u16> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<u16> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ u16> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<u32> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ u32> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<u32> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ u32> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<u64> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ u64> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<u64> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ u64> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<u128> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ u128> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &u128) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<u128> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ u128> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &u128) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<usize> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ usize> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<usize> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ usize> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<i8> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ i8> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<i8> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ i8> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<i16> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ i16> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<i16> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ i16> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<i32> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ i32> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<i32> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ i32> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<i64> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ i64> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<i64> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ i64> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<i128> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: i128) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ i128> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &i128) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<i128> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: i128) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ i128> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &i128) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<isize> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ isize> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<isize> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ isize> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<f32> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ f32> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &f32) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<f32> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ f32> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &f32) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<f64> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ f64> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &f64) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<f64> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ f64> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &f64) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<BigUint> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: BigUint) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ BigUint> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &BigUint) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<BigUint> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: BigUint) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ BigUint> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &BigUint) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<BigInt> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: BigInt) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ BigInt> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &BigInt) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<BigInt> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: BigInt) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ BigInt> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &BigInt) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: Ratio<BigUint>) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &Ratio<BigUint>) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<Ratio<BigUint>> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: Ratio<BigUint>) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ Ratio<BigUint>> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &Ratio<BigUint>) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Add<Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: Ratio<BigInt>) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<&'_ Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &Ratio<BigInt>) -> ModType<C>

Performs the + operation.

impl<'_, C: Cartridge> Add<Ratio<BigInt>> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: Ratio<BigInt>) -> ModType<C>

Performs the + operation.

impl<'_, '_, C: Cartridge> Add<&'_ Ratio<BigInt>> for &'_ ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the + operator.

fn add(self, rhs: &Ratio<BigInt>) -> ModType<C>

Performs the + operation.

impl<C: Cartridge> Sub<ModType<C>> for ModType<C> where
    C: Cartridge<PartialSubtraction = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: ModType<C>) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ ModType<C>> for ModType<C> where
    C: Cartridge<PartialSubtraction = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &ModType<C>) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<ModType<C>> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: ModType<C>) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ ModType<C>> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &ModType<C>) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<u8> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ u8> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<u8> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ u8> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<u16> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ u16> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<u16> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ u16> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<u32> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ u32> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<u32> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ u32> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<u64> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ u64> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<u64> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ u64> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<u128> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ u128> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<u128> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ u128> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<usize> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ usize> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<usize> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ usize> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<i8> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ i8> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<i8> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ i8> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<i16> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ i16> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<i16> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ i16> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<i32> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ i32> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<i32> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ i32> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<i64> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ i64> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<i64> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ i64> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<i128> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ i128> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<i128> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ i128> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<isize> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ isize> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<isize> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ isize> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<f32> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ f32> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &f32) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<f32> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ f32> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &f32) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<f64> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ f64> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &f64) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<f64> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ f64> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &f64) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<BigUint> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: BigUint) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ BigUint> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &BigUint) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<BigUint> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: BigUint) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ BigUint> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &BigUint) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<BigInt> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: BigInt) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ BigInt> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &BigInt) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<BigInt> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: BigInt) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ BigInt> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &BigInt) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: Ratio<BigUint>) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ratio<BigUint>) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<Ratio<BigUint>> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: Ratio<BigUint>) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ Ratio<BigUint>> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ratio<BigUint>) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Sub<Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: Ratio<BigInt>) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<&'_ Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ratio<BigInt>) -> ModType<C>

Performs the - operation.

impl<'_, C: Cartridge> Sub<Ratio<BigInt>> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: Ratio<BigInt>) -> ModType<C>

Performs the - operation.

impl<'_, '_, C: Cartridge> Sub<&'_ Ratio<BigInt>> for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ratio<BigInt>) -> ModType<C>

Performs the - operation.

impl<C: Cartridge> Mul<ModType<C>> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: ModType<C>) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ ModType<C>> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &ModType<C>) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<ModType<C>> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: ModType<C>) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ ModType<C>> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &ModType<C>) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<u8> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ u8> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<u8> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ u8> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<u16> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ u16> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<u16> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ u16> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<u32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ u32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<u32> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ u32> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<u64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ u64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<u64> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ u64> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<u128> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ u128> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &u128) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<u128> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ u128> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &u128) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<usize> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ usize> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<usize> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ usize> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<i8> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ i8> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<i8> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ i8> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<i16> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ i16> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<i16> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ i16> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<i32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ i32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<i32> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ i32> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<i64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ i64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<i64> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ i64> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<i128> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ i128> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &i128) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<i128> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ i128> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &i128) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<isize> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ isize> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<isize> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ isize> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<f32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ f32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &f32) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<f32> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ f32> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &f32) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<f64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ f64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &f64) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<f64> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ f64> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &f64) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<BigUint> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: BigUint) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ BigUint> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &BigUint) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<BigUint> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: BigUint) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ BigUint> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &BigUint) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<BigInt> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: BigInt) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ BigInt> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &BigInt) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<BigInt> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: BigInt) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ BigInt> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &BigInt) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: Ratio<BigUint>) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ratio<BigUint>) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<Ratio<BigUint>> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: Ratio<BigUint>) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ Ratio<BigUint>> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ratio<BigUint>) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Mul<Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: Ratio<BigInt>) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<&'_ Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ratio<BigInt>) -> ModType<C>

Performs the * operation.

impl<'_, C: Cartridge> Mul<Ratio<BigInt>> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: Ratio<BigInt>) -> ModType<C>

Performs the * operation.

impl<'_, '_, C: Cartridge> Mul<&'_ Ratio<BigInt>> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &Ratio<BigInt>) -> ModType<C>

Performs the * operation.

impl<C: Cartridge> Div<ModType<C>> for ModType<C> where
    C: Cartridge<PartialDivision = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: ModType<C>) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ ModType<C>> for ModType<C> where
    C: Cartridge<PartialDivision = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &ModType<C>) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<ModType<C>> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: ModType<C>) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ ModType<C>> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &ModType<C>) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<u8> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ u8> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<u8> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ u8> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<u16> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ u16> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<u16> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ u16> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<u32> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ u32> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<u32> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ u32> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<u64> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ u64> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<u64> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ u64> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<u128> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ u128> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &u128) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<u128> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ u128> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &u128) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<usize> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ usize> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<usize> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ usize> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<i8> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ i8> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<i8> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ i8> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<i16> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ i16> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<i16> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ i16> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<i32> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ i32> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<i32> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ i32> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<i64> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ i64> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<i64> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ i64> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<i128> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ i128> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &i128) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<i128> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ i128> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &i128) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<isize> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ isize> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<isize> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ isize> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<f32> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ f32> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &f32) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<f32> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ f32> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &f32) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<f64> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ f64> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &f64) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<f64> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ f64> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &f64) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<BigUint> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: BigUint) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ BigUint> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &BigUint) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<BigUint> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: BigUint) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ BigUint> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &BigUint) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<BigInt> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: BigInt) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ BigInt> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &BigInt) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<BigInt> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: BigInt) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ BigInt> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &BigInt) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: Ratio<BigUint>) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &Ratio<BigUint>) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<Ratio<BigUint>> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: Ratio<BigUint>) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ Ratio<BigUint>> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &Ratio<BigUint>) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Div<Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: Ratio<BigInt>) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<&'_ Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &Ratio<BigInt>) -> ModType<C>

Performs the / operation.

impl<'_, C: Cartridge> Div<Ratio<BigInt>> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: Ratio<BigInt>) -> ModType<C>

Performs the / operation.

impl<'_, '_, C: Cartridge> Div<&'_ Ratio<BigInt>> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the / operator.

fn div(self, rhs: &Ratio<BigInt>) -> ModType<C>

Performs the / operation.

impl<C: Cartridge> Rem<ModType<C>> for ModType<C> where
    C: Cartridge<PartialDivision = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: ModType<C>) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ ModType<C>> for ModType<C> where
    C: Cartridge<PartialDivision = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &ModType<C>) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<ModType<C>> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: ModType<C>) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ ModType<C>> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &ModType<C>) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<u8> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ u8> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &u8) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<u8> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ u8> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &u8) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<u16> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ u16> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &u16) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<u16> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ u16> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &u16) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<u32> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ u32> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<u32> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ u32> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<u64> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ u64> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &u64) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<u64> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ u64> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &u64) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<u128> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: u128) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ u128> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &u128) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<u128> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: u128) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ u128> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &u128) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<usize> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: usize) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ usize> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &usize) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<usize> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: usize) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ usize> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &usize) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<i8> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ i8> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &i8) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<i8> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ i8> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &i8) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<i16> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ i16> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &i16) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<i16> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ i16> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &i16) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<i32> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ i32> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<i32> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ i32> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<i64> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ i64> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &i64) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<i64> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ i64> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &i64) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<i128> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ i128> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &i128) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<i128> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ i128> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &i128) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<isize> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ isize> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &isize) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<isize> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ isize> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &isize) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<f32> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ f32> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &f32) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<f32> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ f32> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &f32) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<f64> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ f64> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &f64) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<f64> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ f64> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &f64) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<BigUint> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: BigUint) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ BigUint> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &BigUint) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<BigUint> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: BigUint) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ BigUint> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &BigUint) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<BigInt> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: BigInt) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ BigInt> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &BigInt) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<BigInt> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: BigInt) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ BigInt> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &BigInt) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: Ratio<BigUint>) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ratio<BigUint>) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<Ratio<BigUint>> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: Ratio<BigUint>) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ Ratio<BigUint>> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ratio<BigUint>) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Rem<Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: Ratio<BigInt>) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<&'_ Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ratio<BigInt>) -> ModType<C>

Performs the % operation.

impl<'_, C: Cartridge> Rem<Ratio<BigInt>> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: Ratio<BigInt>) -> ModType<C>

Performs the % operation.

impl<'_, '_, C: Cartridge> Rem<&'_ Ratio<BigInt>> for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True>, 

type Output = ModType<C>

The resulting type after applying the % operator.

fn rem(self, rhs: &Ratio<BigInt>) -> ModType<C>

Performs the % operation.

impl<C: Cartridge> Neg for ModType<C> where
    C: Cartridge<PartialSubtraction = True>, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<'_, C: Cartridge> Neg for &'_ ModType<C> where
    C: Cartridge<PartialSubtraction = True>, 

type Output = ModType<C>

The resulting type after applying the - operator.

fn neg(self) -> ModType<C>

Performs the unary - operation.

impl<C: Cartridge> AddAssign<ModType<C>> for ModType<C> where
    C: Cartridge<PartialAddition = True>, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ ModType<C>> for ModType<C> where
    C: Cartridge<PartialAddition = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<u8> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ u8> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<u16> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ u16> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<u32> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ u32> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<u64> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ u64> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<u128> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ u128> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<usize> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ usize> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<i8> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ i8> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<i16> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ i16> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<i32> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ i32> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<i64> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ i64> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<i128> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: i128)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ i128> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<isize> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ isize> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<f32> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ f32> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<f64> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: f64)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ f64> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<BigUint> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: BigUint)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ BigUint> for ModType<C> where
    C: Cartridge<PartialAddition = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<BigInt> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: BigInt)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ BigInt> for ModType<C> where
    C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the += operation.

impl<C: Cartridge> AddAssign<Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: Ratio<BigUint>)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: &Ratio<BigUint>)

Performs the += operation.

impl<C: Cartridge> AddAssign<Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: Ratio<BigInt>)

Performs the += operation.

impl<'_, C: Cartridge> AddAssign<&'_ Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

fn add_assign(&mut self, rhs: &Ratio<BigInt>)

Performs the += operation.

impl<C: Cartridge> SubAssign<ModType<C>> for ModType<C> where
    C: Cartridge<PartialSubtraction = True>, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ ModType<C>> for ModType<C> where
    C: Cartridge<PartialSubtraction = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<u8> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ u8> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<u16> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ u16> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<u32> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ u32> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<u64> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ u64> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<u128> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ u128> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<usize> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ usize> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<i8> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ i8> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<i16> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ i16> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<i32> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ i32> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<i64> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ i64> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<i128> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: i128)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ i128> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<isize> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ isize> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<f32> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ f32> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<f64> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: f64)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ f64> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<BigUint> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: BigUint)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ BigUint> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<BigInt> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: BigInt)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ BigInt> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, FlexibleRhs = True>, 

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

Performs the -= operation.

impl<C: Cartridge> SubAssign<Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: Ratio<BigUint>)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: &Ratio<BigUint>)

Performs the -= operation.

impl<C: Cartridge> SubAssign<Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: Ratio<BigInt>)

Performs the -= operation.

impl<'_, C: Cartridge> SubAssign<&'_ Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

fn sub_assign(&mut self, rhs: &Ratio<BigInt>)

Performs the -= operation.

impl<C: Cartridge> MulAssign<ModType<C>> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ ModType<C>> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

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

Performs the *= operation.

impl<C: Cartridge> MulAssign<u8> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ u8> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &u8)

Performs the *= operation.

impl<C: Cartridge> MulAssign<u16> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ u16> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &u16)

Performs the *= operation.

impl<C: Cartridge> MulAssign<u32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ u32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &u32)

Performs the *= operation.

impl<C: Cartridge> MulAssign<u64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ u64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &u64)

Performs the *= operation.

impl<C: Cartridge> MulAssign<u128> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: u128)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ u128> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &u128)

Performs the *= operation.

impl<C: Cartridge> MulAssign<usize> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ usize> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &usize)

Performs the *= operation.

impl<C: Cartridge> MulAssign<i8> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ i8> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &i8)

Performs the *= operation.

impl<C: Cartridge> MulAssign<i16> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ i16> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &i16)

Performs the *= operation.

impl<C: Cartridge> MulAssign<i32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ i32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &i32)

Performs the *= operation.

impl<C: Cartridge> MulAssign<i64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ i64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &i64)

Performs the *= operation.

impl<C: Cartridge> MulAssign<i128> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ i128> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &i128)

Performs the *= operation.

impl<C: Cartridge> MulAssign<isize> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: isize)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ isize> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &isize)

Performs the *= operation.

impl<C: Cartridge> MulAssign<f32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ f32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &f32)

Performs the *= operation.

impl<C: Cartridge> MulAssign<f64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ f64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &f64)

Performs the *= operation.

impl<C: Cartridge> MulAssign<BigUint> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: BigUint)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ BigUint> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &BigUint)

Performs the *= operation.

impl<C: Cartridge> MulAssign<BigInt> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: BigInt)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ BigInt> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &BigInt)

Performs the *= operation.

impl<C: Cartridge> MulAssign<Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: Ratio<BigUint>)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &Ratio<BigUint>)

Performs the *= operation.

impl<C: Cartridge> MulAssign<Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: Ratio<BigInt>)

Performs the *= operation.

impl<'_, C: Cartridge> MulAssign<&'_ Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True>, 

fn mul_assign(&mut self, rhs: &Ratio<BigInt>)

Performs the *= operation.

impl<C: Cartridge> DivAssign<ModType<C>> for ModType<C> where
    C: Cartridge<PartialDivision = True>, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ ModType<C>> for ModType<C> where
    C: Cartridge<PartialDivision = True>, 

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

Performs the /= operation.

impl<C: Cartridge> DivAssign<u8> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ u8> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &u8)

Performs the /= operation.

impl<C: Cartridge> DivAssign<u16> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ u16> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &u16)

Performs the /= operation.

impl<C: Cartridge> DivAssign<u32> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ u32> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &u32)

Performs the /= operation.

impl<C: Cartridge> DivAssign<u64> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ u64> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &u64)

Performs the /= operation.

impl<C: Cartridge> DivAssign<u128> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: u128)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ u128> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &u128)

Performs the /= operation.

impl<C: Cartridge> DivAssign<usize> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ usize> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &usize)

Performs the /= operation.

impl<C: Cartridge> DivAssign<i8> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ i8> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &i8)

Performs the /= operation.

impl<C: Cartridge> DivAssign<i16> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ i16> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &i16)

Performs the /= operation.

impl<C: Cartridge> DivAssign<i32> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ i32> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &i32)

Performs the /= operation.

impl<C: Cartridge> DivAssign<i64> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ i64> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &i64)

Performs the /= operation.

impl<C: Cartridge> DivAssign<i128> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ i128> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &i128)

Performs the /= operation.

impl<C: Cartridge> DivAssign<isize> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ isize> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &isize)

Performs the /= operation.

impl<C: Cartridge> DivAssign<f32> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ f32> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &f32)

Performs the /= operation.

impl<C: Cartridge> DivAssign<f64> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ f64> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &f64)

Performs the /= operation.

impl<C: Cartridge> DivAssign<BigUint> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: BigUint)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ BigUint> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &BigUint)

Performs the /= operation.

impl<C: Cartridge> DivAssign<BigInt> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: BigInt)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ BigInt> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &BigInt)

Performs the /= operation.

impl<C: Cartridge> DivAssign<Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: Ratio<BigUint>)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &Ratio<BigUint>)

Performs the /= operation.

impl<C: Cartridge> DivAssign<Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: Ratio<BigInt>)

Performs the /= operation.

impl<'_, C: Cartridge> DivAssign<&'_ Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn div_assign(&mut self, rhs: &Ratio<BigInt>)

Performs the /= operation.

impl<C: Cartridge> RemAssign<ModType<C>> for ModType<C> where
    C: Cartridge<PartialDivision = True>, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ ModType<C>> for ModType<C> where
    C: Cartridge<PartialDivision = True>, 

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

Performs the %= operation.

impl<C: Cartridge> RemAssign<u8> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: u8)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ u8> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &u8)

Performs the %= operation.

impl<C: Cartridge> RemAssign<u16> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: u16)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ u16> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &u16)

Performs the %= operation.

impl<C: Cartridge> RemAssign<u32> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ u32> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &u32)

Performs the %= operation.

impl<C: Cartridge> RemAssign<u64> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: u64)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ u64> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &u64)

Performs the %= operation.

impl<C: Cartridge> RemAssign<u128> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: u128)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ u128> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &u128)

Performs the %= operation.

impl<C: Cartridge> RemAssign<usize> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: usize)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ usize> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &usize)

Performs the %= operation.

impl<C: Cartridge> RemAssign<i8> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: i8)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ i8> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &i8)

Performs the %= operation.

impl<C: Cartridge> RemAssign<i16> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: i16)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ i16> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &i16)

Performs the %= operation.

impl<C: Cartridge> RemAssign<i32> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ i32> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &i32)

Performs the %= operation.

impl<C: Cartridge> RemAssign<i64> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: i64)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ i64> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &i64)

Performs the %= operation.

impl<C: Cartridge> RemAssign<i128> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: i128)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ i128> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &i128)

Performs the %= operation.

impl<C: Cartridge> RemAssign<isize> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: isize)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ isize> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &isize)

Performs the %= operation.

impl<C: Cartridge> RemAssign<f32> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: f32)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ f32> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &f32)

Performs the %= operation.

impl<C: Cartridge> RemAssign<f64> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: f64)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ f64> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &f64)

Performs the %= operation.

impl<C: Cartridge> RemAssign<BigUint> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: BigUint)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ BigUint> for ModType<C> where
    C: Cartridge<PartialDivision = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &BigUint)

Performs the %= operation.

impl<C: Cartridge> RemAssign<BigInt> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: BigInt)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ BigInt> for ModType<C> where
    C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &BigInt)

Performs the %= operation.

impl<C: Cartridge> RemAssign<Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: Ratio<BigUint>)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ Ratio<BigUint>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &Ratio<BigUint>)

Performs the %= operation.

impl<C: Cartridge> RemAssign<Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: Ratio<BigInt>)

Performs the %= operation.

impl<'_, C: Cartridge> RemAssign<&'_ Ratio<BigInt>> for ModType<C> where
    C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True>, 

fn rem_assign(&mut self, rhs: &Ratio<BigInt>)

Performs the %= operation.

impl<C: Cartridge> CheckedNeg for ModType<C> where
    C: Cartridge<PartialSubtraction = True>, 

fn checked_neg(&self) -> Option<Self>

Negates a number, returning None for results that can't be represented, like signed MIN values that can't be positive, or non-zero unsigned values that can't be negative.

impl<C: Cartridge> CheckedAdd for ModType<C> where
    C: Cartridge<PartialAddition = True>, 

fn checked_add(&self, rhs: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<C: Cartridge> CheckedMul for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

fn checked_mul(&self, rhs: &Self) -> Option<Self>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl<C: Cartridge> CheckedSub for ModType<C> where
    C: Cartridge<PartialSubtraction = True>, 

fn checked_sub(&self, rhs: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl<C: Cartridge> CheckedRem for ModType<C> where
    C: Cartridge<PartialDivision = True>, 

fn checked_rem(&self, rhs: &Self) -> Option<Self>

Finds the remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<C: Cartridge> CheckedDiv for ModType<C> where
    C: Cartridge<PartialDivision = True>, 

fn checked_div(&self, rhs: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<C: Cartridge> Pow<u8> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: u8) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<&'_ u8> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: &u8) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<u8> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: u8) -> ModType<C>

Returns self to the power rhs.

impl<'_, '_, C: Cartridge> Pow<&'_ u8> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &u8) -> ModType<C>

Returns self to the power rhs.

impl<C: Cartridge> Pow<u16> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: u16) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<&'_ u16> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: &u16) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<u16> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: u16) -> ModType<C>

Returns self to the power rhs.

impl<'_, '_, C: Cartridge> Pow<&'_ u16> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &u16) -> ModType<C>

Returns self to the power rhs.

impl<C: Cartridge> Pow<u32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: u32) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<&'_ u32> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: &u32) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<u32> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: u32) -> ModType<C>

Returns self to the power rhs.

impl<'_, '_, C: Cartridge> Pow<&'_ u32> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &u32) -> ModType<C>

Returns self to the power rhs.

impl<C: Cartridge> Pow<u64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: u64) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<&'_ u64> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: &u64) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<u64> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: u64) -> ModType<C>

Returns self to the power rhs.

impl<'_, '_, C: Cartridge> Pow<&'_ u64> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &u64) -> ModType<C>

Returns self to the power rhs.

impl<C: Cartridge> Pow<u128> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: u128) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<&'_ u128> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: &u128) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<u128> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: u128) -> ModType<C>

Returns self to the power rhs.

impl<'_, '_, C: Cartridge> Pow<&'_ u128> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &u128) -> ModType<C>

Returns self to the power rhs.

impl<C: Cartridge> Pow<usize> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: usize) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<&'_ usize> for ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: &usize) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<usize> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: usize) -> ModType<C>

Returns self to the power rhs.

impl<'_, '_, C: Cartridge> Pow<&'_ usize> for &'_ ModType<C> where
    C: Cartridge<PartialMultiplication = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &usize) -> ModType<C>

Returns self to the power rhs.

impl<C: Cartridge> Pow<i8> for ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: i8) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<&'_ i8> for ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: &i8) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<i8> for &'_ ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: i8) -> ModType<C>

Returns self to the power rhs.

impl<'_, '_, C: Cartridge> Pow<&'_ i8> for &'_ ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &i8) -> ModType<C>

Returns self to the power rhs.

impl<C: Cartridge> Pow<i16> for ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: i16) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<&'_ i16> for ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: &i16) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<i16> for &'_ ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: i16) -> ModType<C>

Returns self to the power rhs.

impl<'_, '_, C: Cartridge> Pow<&'_ i16> for &'_ ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &i16) -> ModType<C>

Returns self to the power rhs.

impl<C: Cartridge> Pow<i32> for ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: i32) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<&'_ i32> for ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: &i32) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<i32> for &'_ ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: i32) -> ModType<C>

Returns self to the power rhs.

impl<'_, '_, C: Cartridge> Pow<&'_ i32> for &'_ ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &i32) -> ModType<C>

Returns self to the power rhs.

impl<C: Cartridge> Pow<i64> for ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: i64) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<&'_ i64> for ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: &i64) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<i64> for &'_ ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: i64) -> ModType<C>

Returns self to the power rhs.

impl<'_, '_, C: Cartridge> Pow<&'_ i64> for &'_ ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &i64) -> ModType<C>

Returns self to the power rhs.

impl<C: Cartridge> Pow<i128> for ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: i128) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<&'_ i128> for ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: &i128) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<i128> for &'_ ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: i128) -> ModType<C>

Returns self to the power rhs.

impl<'_, '_, C: Cartridge> Pow<&'_ i128> for &'_ ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &i128) -> ModType<C>

Returns self to the power rhs.

impl<C: Cartridge> Pow<isize> for ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: isize) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<&'_ isize> for ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = Self

The result after applying the operator.

fn pow(self, exp: &isize) -> Self

Returns self to the power rhs.

impl<'_, C: Cartridge> Pow<isize> for &'_ ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: isize) -> ModType<C>

Returns self to the power rhs.

impl<'_, '_, C: Cartridge> Pow<&'_ isize> for &'_ ModType<C> where
    C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &isize) -> ModType<C>

Returns self to the power rhs.

impl<C: Cartridge> Inv for ModType<C> where
    C: Cartridge<PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn inv(self) -> ModType<C>

Returns the multiplicative inverse of self.

impl<'_, C: Cartridge> Inv for &'_ ModType<C> where
    C: Cartridge<PartialDivision = True>, 

type Output = ModType<C>

The result after applying the operator.

fn inv(self) -> ModType<C>

Returns the multiplicative inverse of self.