Struct ModType 

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

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");

Implementations

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> Add<&BigInt> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&BigInt> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&BigUint> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&BigUint> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&ModType<C>> for &ModType<C>

where C: Cartridge<PartialAddition = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&ModType<C>> for ModType<C>

where C: Cartridge<PartialAddition = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&Ratio<BigInt>> for &ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&Ratio<BigUint>> for &ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&f32> for &ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&f32> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&f64> for &ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&f64> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&i128> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&i128> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&i16> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&i16> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&i32> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&i32> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&i64> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&i64> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&i8> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&i8> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&isize> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&isize> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&u128> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&u128> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&u16> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&u16> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&u32> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&u32> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&u64> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&u64> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&u8> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&u8> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&usize> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<&usize> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<BigInt> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<BigInt> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<BigUint> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<BigUint> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<ModType<C>> for &ModType<C>

where C: Cartridge<PartialAddition = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<Ratio<BigInt>> for &ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<Ratio<BigUint>> for &ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<f32> for &ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<f32> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<f64> for &ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<f64> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<i128> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<i128> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<i16> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<i16> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<i32> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<i32> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<i64> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<i64> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<i8> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<i8> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<isize> for &ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<isize> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<u128> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<u128> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<u16> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<u16> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<u32> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<u32> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<u64> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<u64> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<u8> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<u8> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<usize> for &ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add<usize> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> Add for ModType<C>

where C: Cartridge<PartialAddition = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> AddAssign<&BigInt> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&BigUint> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&ModType<C>> for ModType<C>

where C: Cartridge<PartialAddition = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: &Ratio<BigInt>)

Performs the += operation.

impl<C> AddAssign<&Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: &Ratio<BigUint>)

Performs the += operation.

impl<C> AddAssign<&f32> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&f64> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&i128> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&i16> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&i32> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&i64> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&i8> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&isize> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&u128> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&u16> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&u32> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&u64> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&u8> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<&usize> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

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

Performs the += operation.

impl<C> AddAssign<BigInt> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: BigInt)

Performs the += operation.

impl<C> AddAssign<BigUint> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: BigUint)

Performs the += operation.

impl<C> AddAssign<Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: Ratio<BigInt>)

Performs the += operation.

impl<C> AddAssign<Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: Ratio<BigUint>)

Performs the += operation.

impl<C> AddAssign<f32> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

impl<C> AddAssign<f64> for ModType<C>

where C: Cartridge<PartialAddition = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: f64)

Performs the += operation.

impl<C> AddAssign<i128> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: i128)

Performs the += operation.

impl<C> AddAssign<i16> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<C> AddAssign<i32> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<C> AddAssign<i64> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<C> AddAssign<i8> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<C> AddAssign<isize> for ModType<C>

where C: Cartridge<PartialAddition = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

impl<C> AddAssign<u128> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl<C> AddAssign<u16> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<C> AddAssign<u32> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<C> AddAssign<u64> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<C> AddAssign<u8> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<C> AddAssign<usize> for ModType<C>

where C: Cartridge<PartialAddition = True, FlexibleRhs = True> + Cartridge,

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl<C> AddAssign for ModType<C>

where C: Cartridge<PartialAddition = True> + Cartridge,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<C> CheckedAdd for ModType<C>

where C: Cartridge<PartialAddition = True> + Cartridge,

fn checked_add(&self, rhs: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<C> CheckedDiv for ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

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> CheckedMul for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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> CheckedNeg for ModType<C>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

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> CheckedRem for ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

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> CheckedSub for ModType<C>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

fn checked_sub(&self, rhs: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<C> Deref for ModType<C>

where C: Cartridge<Deref = True> + Cartridge,

type Target = <C as Cartridge>::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> Div<&BigInt> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&BigInt> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&BigUint> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&BigUint> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&ModType<C>> for &ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&ModType<C>> for ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&Ratio<BigInt>> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&Ratio<BigUint>> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&f32> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&f32> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&f64> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&f64> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&i128> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&i128> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&i16> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&i16> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&i32> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&i32> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&i64> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&i64> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&i8> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&i8> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&isize> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&isize> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&u128> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&u128> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&u16> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&u16> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&u32> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&u32> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&u64> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&u64> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&u8> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&u8> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&usize> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<&usize> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<BigInt> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<BigInt> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<BigUint> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<BigUint> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<ModType<C>> for &ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<Ratio<BigInt>> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<Ratio<BigUint>> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<f32> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<f32> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<f64> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<f64> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<i128> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<i128> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<i16> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<i16> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<i32> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<i32> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<i64> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<i64> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<i8> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<i8> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<isize> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<isize> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<u128> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<u128> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<u16> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<u16> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<u32> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<u32> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<u64> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<u64> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<u8> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<u8> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<usize> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div<usize> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> Div for ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C> DivAssign<&BigInt> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &BigInt)

Performs the /= operation.

impl<C> DivAssign<&BigUint> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &BigUint)

Performs the /= operation.

impl<C> DivAssign<&ModType<C>> for ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

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

Performs the /= operation.

impl<C> DivAssign<&Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &Ratio<BigInt>)

Performs the /= operation.

impl<C> DivAssign<&Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &Ratio<BigUint>)

Performs the /= operation.

impl<C> DivAssign<&f32> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &f32)

Performs the /= operation.

impl<C> DivAssign<&f64> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &f64)

Performs the /= operation.

impl<C> DivAssign<&i128> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &i128)

Performs the /= operation.

impl<C> DivAssign<&i16> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &i16)

Performs the /= operation.

impl<C> DivAssign<&i32> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &i32)

Performs the /= operation.

impl<C> DivAssign<&i64> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &i64)

Performs the /= operation.

impl<C> DivAssign<&i8> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &i8)

Performs the /= operation.

impl<C> DivAssign<&isize> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &isize)

Performs the /= operation.

impl<C> DivAssign<&u128> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &u128)

Performs the /= operation.

impl<C> DivAssign<&u16> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &u16)

Performs the /= operation.

impl<C> DivAssign<&u32> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &u32)

Performs the /= operation.

impl<C> DivAssign<&u64> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &u64)

Performs the /= operation.

impl<C> DivAssign<&u8> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &u8)

Performs the /= operation.

impl<C> DivAssign<&usize> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: &usize)

Performs the /= operation.

impl<C> DivAssign<BigInt> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: BigInt)

Performs the /= operation.

impl<C> DivAssign<BigUint> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: BigUint)

Performs the /= operation.

impl<C> DivAssign<Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: Ratio<BigInt>)

Performs the /= operation.

impl<C> DivAssign<Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: Ratio<BigUint>)

Performs the /= operation.

impl<C> DivAssign<f32> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl<C> DivAssign<f64> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl<C> DivAssign<i128> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl<C> DivAssign<i16> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<C> DivAssign<i32> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<C> DivAssign<i64> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<C> DivAssign<i8> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<C> DivAssign<isize> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl<C> DivAssign<u128> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: u128)

Performs the /= operation.

impl<C> DivAssign<u16> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<C> DivAssign<u32> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<C> DivAssign<u64> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<C> DivAssign<u8> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<C> DivAssign<usize> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl<C> DivAssign for ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<C> Inv for &ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn inv(self) -> ModType<C>

Returns the multiplicative inverse of self.

impl<C> Inv for ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn inv(self) -> ModType<C>

Returns the multiplicative inverse of self.

impl<C> Mul<&BigInt> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&BigInt> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&BigUint> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&BigUint> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&ModType<C>> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&ModType<C>> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&Ratio<BigInt>> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&Ratio<BigUint>> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&f32> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&f32> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&f64> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&f64> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&i128> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&i128> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&i16> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&i16> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&i32> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&i32> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&i64> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&i64> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&i8> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&i8> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&isize> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&isize> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&u128> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&u128> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&u16> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&u16> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&u32> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&u32> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&u64> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&u64> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&u8> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&u8> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&usize> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<&usize> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<BigInt> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<BigInt> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<BigUint> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<BigUint> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<ModType<C>> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<Ratio<BigInt>> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<Ratio<BigUint>> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<f32> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<f32> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<f64> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<f64> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<i128> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<i128> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<i16> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<i16> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<i32> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<i32> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<i64> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<i64> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<i8> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<i8> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<isize> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<isize> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<u128> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<u128> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<u16> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<u16> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<u32> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<u32> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<u64> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<u64> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<u8> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<u8> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<usize> for &ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<usize> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> MulAssign<&BigInt> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &BigInt)

Performs the *= operation.

impl<C> MulAssign<&BigUint> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &BigUint)

Performs the *= operation.

impl<C> MulAssign<&ModType<C>> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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

Performs the *= operation.

impl<C> MulAssign<&Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &Ratio<BigInt>)

Performs the *= operation.

impl<C> MulAssign<&Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &Ratio<BigUint>)

Performs the *= operation.

impl<C> MulAssign<&f32> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &f32)

Performs the *= operation.

impl<C> MulAssign<&f64> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &f64)

Performs the *= operation.

impl<C> MulAssign<&i128> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &i128)

Performs the *= operation.

impl<C> MulAssign<&i16> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &i16)

Performs the *= operation.

impl<C> MulAssign<&i32> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &i32)

Performs the *= operation.

impl<C> MulAssign<&i64> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &i64)

Performs the *= operation.

impl<C> MulAssign<&i8> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &i8)

Performs the *= operation.

impl<C> MulAssign<&isize> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &isize)

Performs the *= operation.

impl<C> MulAssign<&u128> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &u128)

Performs the *= operation.

impl<C> MulAssign<&u16> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &u16)

Performs the *= operation.

impl<C> MulAssign<&u32> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &u32)

Performs the *= operation.

impl<C> MulAssign<&u64> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &u64)

Performs the *= operation.

impl<C> MulAssign<&u8> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &u8)

Performs the *= operation.

impl<C> MulAssign<&usize> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: &usize)

Performs the *= operation.

impl<C> MulAssign<BigInt> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: BigInt)

Performs the *= operation.

impl<C> MulAssign<BigUint> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: BigUint)

Performs the *= operation.

impl<C> MulAssign<Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: Ratio<BigInt>)

Performs the *= operation.

impl<C> MulAssign<Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: Ratio<BigUint>)

Performs the *= operation.

impl<C> MulAssign<f32> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl<C> MulAssign<f64> for ModType<C>

where C: Cartridge<PartialMultiplication = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl<C> MulAssign<i128> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl<C> MulAssign<i16> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<C> MulAssign<i32> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<C> MulAssign<i64> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<C> MulAssign<i8> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<C> MulAssign<isize> for ModType<C>

where C: Cartridge<PartialMultiplication = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: isize)

Performs the *= operation.

impl<C> MulAssign<u128> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: u128)

Performs the *= operation.

impl<C> MulAssign<u16> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<C> MulAssign<u32> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<C> MulAssign<u64> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<C> MulAssign<u8> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<C> MulAssign<usize> for ModType<C>

where C: Cartridge<PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl<C> MulAssign for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<C> Neg for &ModType<C>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

fn neg(self) -> ModType<C>

Performs the unary - operation.

impl<C> Neg for ModType<C>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<C> Ord for ModType<C>

where C: Cartridge<Equality = True, Order = True> + Cartridge,

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<C> PartialEq for ModType<C>

where C: Cartridge<Equality = True> + Cartridge,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<C> PartialOrd for ModType<C>

where C: Cartridge<Equality = True, Order = True> + Cartridge,

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

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl<C> Pow<&i128> for &ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

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> Pow<&i128> for ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &i128) -> Self

Returns self to the power rhs.

impl<C> Pow<&i16> for &ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

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> Pow<&i16> for ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &i16) -> Self

Returns self to the power rhs.

impl<C> Pow<&i32> for &ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

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> Pow<&i32> for ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &i32) -> Self

Returns self to the power rhs.

impl<C> Pow<&i64> for &ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

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> Pow<&i64> for ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &i64) -> Self

Returns self to the power rhs.

impl<C> Pow<&i8> for &ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

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> Pow<&i8> for ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &i8) -> Self

Returns self to the power rhs.

impl<C> Pow<&isize> for &ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

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> Pow<&isize> for ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &isize) -> Self

Returns self to the power rhs.

impl<C> Pow<&u128> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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> Pow<&u128> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &u128) -> Self

Returns self to the power rhs.

impl<C> Pow<&u16> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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> Pow<&u16> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &u16) -> Self

Returns self to the power rhs.

impl<C> Pow<&u32> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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> Pow<&u32> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &u32) -> Self

Returns self to the power rhs.

impl<C> Pow<&u64> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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> Pow<&u64> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &u64) -> Self

Returns self to the power rhs.

impl<C> Pow<&u8> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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> Pow<&u8> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &u8) -> Self

Returns self to the power rhs.

impl<C> Pow<&usize> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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> Pow<&usize> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: &usize) -> Self

Returns self to the power rhs.

impl<C> Pow<i128> for &ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

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> Pow<i128> for ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: i128) -> Self

Returns self to the power rhs.

impl<C> Pow<i16> for &ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

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> Pow<i16> for ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: i16) -> Self

Returns self to the power rhs.

impl<C> Pow<i32> for &ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

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> Pow<i32> for ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: i32) -> Self

Returns self to the power rhs.

impl<C> Pow<i64> for &ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

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> Pow<i64> for ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: i64) -> Self

Returns self to the power rhs.

impl<C> Pow<i8> for &ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

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> Pow<i8> for ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: i8) -> Self

Returns self to the power rhs.

impl<C> Pow<isize> for &ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

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> Pow<isize> for ModType<C>

where C: Cartridge<AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: isize) -> Self

Returns self to the power rhs.

impl<C> Pow<u128> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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> Pow<u128> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: u128) -> Self

Returns self to the power rhs.

impl<C> Pow<u16> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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> Pow<u16> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: u16) -> Self

Returns self to the power rhs.

impl<C> Pow<u32> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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> Pow<u32> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: u32) -> Self

Returns self to the power rhs.

impl<C> Pow<u64> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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> Pow<u64> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: u64) -> Self

Returns self to the power rhs.

impl<C> Pow<u8> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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> Pow<u8> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: u8) -> Self

Returns self to the power rhs.

impl<C> Pow<usize> for &ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

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> Pow<usize> for ModType<C>

where C: Cartridge<PartialMultiplication = True> + Cartridge,

type Output = ModType<C>

The result after applying the operator.

fn pow(self, exp: usize) -> Self

Returns self to the power rhs.

impl<C> Rem<&BigInt> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&BigInt> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&BigUint> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&BigUint> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&ModType<C>> for &ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&ModType<C>> for ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&Ratio<BigInt>> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&Ratio<BigUint>> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&f32> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&f32> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&f64> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&f64> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&i128> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&i128> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&i16> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&i16> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&i32> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&i32> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&i64> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&i64> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&i8> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&i8> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&isize> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&isize> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&u128> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&u128> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&u16> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&u16> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&u32> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&u32> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&u64> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&u64> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&u8> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&u8> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&usize> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<&usize> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<BigInt> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<BigInt> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<BigUint> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<BigUint> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<ModType<C>> for &ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<Ratio<BigInt>> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<Ratio<BigUint>> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<f32> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<f32> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<f64> for &ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<f64> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<i128> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<i128> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<i16> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<i16> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<i32> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<i32> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<i64> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<i64> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<i8> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<i8> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<isize> for &ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<isize> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<u128> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<u128> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<u16> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<u16> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<u32> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<u32> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<u64> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<u64> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<u8> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<u8> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<usize> for &ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem<usize> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> Rem for ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C> RemAssign<&BigInt> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &BigInt)

Performs the %= operation.

impl<C> RemAssign<&BigUint> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &BigUint)

Performs the %= operation.

impl<C> RemAssign<&ModType<C>> for ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

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

Performs the %= operation.

impl<C> RemAssign<&Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &Ratio<BigInt>)

Performs the %= operation.

impl<C> RemAssign<&Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &Ratio<BigUint>)

Performs the %= operation.

impl<C> RemAssign<&f32> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &f32)

Performs the %= operation.

impl<C> RemAssign<&f64> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &f64)

Performs the %= operation.

impl<C> RemAssign<&i128> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &i128)

Performs the %= operation.

impl<C> RemAssign<&i16> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &i16)

Performs the %= operation.

impl<C> RemAssign<&i32> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &i32)

Performs the %= operation.

impl<C> RemAssign<&i64> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &i64)

Performs the %= operation.

impl<C> RemAssign<&i8> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &i8)

Performs the %= operation.

impl<C> RemAssign<&isize> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &isize)

Performs the %= operation.

impl<C> RemAssign<&u128> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &u128)

Performs the %= operation.

impl<C> RemAssign<&u16> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &u16)

Performs the %= operation.

impl<C> RemAssign<&u32> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &u32)

Performs the %= operation.

impl<C> RemAssign<&u64> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &u64)

Performs the %= operation.

impl<C> RemAssign<&u8> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &u8)

Performs the %= operation.

impl<C> RemAssign<&usize> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &usize)

Performs the %= operation.

impl<C> RemAssign<BigInt> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: BigInt)

Performs the %= operation.

impl<C> RemAssign<BigUint> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: BigUint)

Performs the %= operation.

impl<C> RemAssign<Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: Ratio<BigInt>)

Performs the %= operation.

impl<C> RemAssign<Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: Ratio<BigUint>)

Performs the %= operation.

impl<C> RemAssign<f32> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: f32)

Performs the %= operation.

impl<C> RemAssign<f64> for ModType<C>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, PartialSubtraction = True, PartialMultiplication = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: f64)

Performs the %= operation.

impl<C> RemAssign<i128> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: i128)

Performs the %= operation.

impl<C> RemAssign<i16> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: i16)

Performs the %= operation.

impl<C> RemAssign<i32> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl<C> RemAssign<i64> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: i64)

Performs the %= operation.

impl<C> RemAssign<i8> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: i8)

Performs the %= operation.

impl<C> RemAssign<isize> for ModType<C>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: isize)

Performs the %= operation.

impl<C> RemAssign<u128> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: u128)

Performs the %= operation.

impl<C> RemAssign<u16> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: u16)

Performs the %= operation.

impl<C> RemAssign<u32> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl<C> RemAssign<u64> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: u64)

Performs the %= operation.

impl<C> RemAssign<u8> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: u8)

Performs the %= operation.

impl<C> RemAssign<usize> for ModType<C>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: usize)

Performs the %= operation.

impl<C> RemAssign for ModType<C>

where C: Cartridge<PartialDivision = True> + Cartridge,

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<C> Sub<&BigInt> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&BigInt> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&BigUint> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&BigUint> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&ModType<C>> for &ModType<C>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&ModType<C>> for ModType<C>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&Ratio<BigInt>> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&Ratio<BigUint>> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&f32> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&f32> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&f64> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&f64> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&i128> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&i128> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&i16> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&i16> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&i32> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&i32> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&i64> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&i64> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&i8> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&i8> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&isize> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&isize> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&u128> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&u128> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&u16> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&u16> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&u32> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&u32> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&u64> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&u64> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&u8> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&u8> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&usize> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<&usize> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<BigInt> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<BigInt> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<BigUint> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<BigUint> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<ModType<C>> for &ModType<C>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<Ratio<BigInt>> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<Ratio<BigUint>> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<f32> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<f32> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<f64> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<f64> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<i128> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<i128> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<i16> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<i16> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<i32> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<i32> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<i64> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<i64> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<i8> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<i8> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<isize> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<isize> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<u128> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<u128> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<u16> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<u16> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<u32> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<u32> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<u64> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<u64> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<u8> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<u8> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<usize> for &ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub<usize> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> Sub for ModType<C>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

type Output = ModType<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> SubAssign<&BigInt> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&BigUint> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&ModType<C>> for ModType<C>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &Ratio<BigInt>)

Performs the -= operation.

impl<C> SubAssign<&Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &Ratio<BigUint>)

Performs the -= operation.

impl<C> SubAssign<&f32> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&f64> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&i128> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&i16> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&i32> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&i64> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&i8> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&isize> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&u128> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&u16> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&u32> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&u64> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&u8> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<&usize> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

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

Performs the -= operation.

impl<C> SubAssign<BigInt> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: BigInt)

Performs the -= operation.

impl<C> SubAssign<BigUint> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: BigUint)

Performs the -= operation.

impl<C> SubAssign<Ratio<BigInt>> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: Ratio<BigInt>)

Performs the -= operation.

impl<C> SubAssign<Ratio<BigUint>> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: Ratio<BigUint>)

Performs the -= operation.

impl<C> SubAssign<f32> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl<C> SubAssign<f64> for ModType<C>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: f64)

Performs the -= operation.

impl<C> SubAssign<i128> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: i128)

Performs the -= operation.

impl<C> SubAssign<i16> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<C> SubAssign<i32> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<C> SubAssign<i64> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<C> SubAssign<i8> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<C> SubAssign<isize> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl<C> SubAssign<u128> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl<C> SubAssign<u16> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<C> SubAssign<u32> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<C> SubAssign<u64> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<C> SubAssign<u8> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<C> SubAssign<usize> for ModType<C>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

impl<C> SubAssign for ModType<C>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

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

impl<C> Eq for ModType<C>

where C: Cartridge<Equality = True> + Cartridge,