Struct ModType

pub struct ModType<C: Cartridge, M: ConstValue<Value = C::Target>> { /* private fields */ }

A modular arithmetic integer type which modulus is a constant.

Examples

use num::bigint::{ToBigInt as _, ToBigUint as _};
use num::pow::Pow as _;
use num::rational::Ratio;
use num::traits::{CheckedNeg as _, CheckedRem as _, Inv as _};
use num::{
    BigInt, BigUint, CheckedAdd as _, CheckedDiv as _, CheckedMul as _, CheckedSub as _,
    FromPrimitive as _, Num as _, One as _, ToPrimitive as _, Zero as _,
};

#[modtype::use_modtype]
type F = modtype::F<7u32>;

// Constructor, `new`, `new_unchecked`, `get_mut_unchecked`, `sqrt`
assert_eq!(F::new(8), F(1));
assert_ne!(F::new_unchecked(8), F(1));
assert_eq!(*F(3).get_mut_unchecked(), 3u32);
assert_eq!(F(2).sqrt(), Some(F(4)));

// `From<{{integer}, {float}, BigUint, BigInt, Ratio<BigUint>, Ratio<BigInt>}>`
assert_eq!(F::from(3u8), F(3));
assert_eq!(F::from(3u16), F(3));
assert_eq!(F::from(3u32), F(3));
assert_eq!(F::from(3u64), F(3));
assert_eq!(F::from(3u128), F(3));
assert_eq!(F::from(3usize), F(3));
assert_eq!(F::from(-3i8), F(4));
assert_eq!(F::from(-3i16), F(4));
assert_eq!(F::from(-3i32), F(4));
assert_eq!(F::from(-3i64), F(4));
assert_eq!(F::from(-3i128), F(4));
assert_eq!(F::from(-3isize), F(4));
assert_eq!(F::from(0.5f32), F(1) / F(2));
assert_eq!(F::from(0.5f64), F(1) / F(2));
assert_eq!(F::from(BigUint::from(3u32)), F(3));
assert_eq!(F::from(BigInt::from(-4i32)), F(3));
assert_eq!(
    F::from(Ratio::new(BigUint::from(8u32), BigUint::from(3u32))),
    F(5),
);
assert_eq!(
    F::from(Ratio::new(BigInt::from(-1i32), BigInt::from(3u32))),
    F(2),
);

// `Display`, `Debug`
assert_eq!(F(3).to_string(), "3");
assert_eq!(format!("{:?}", F(3)), "3");

// `FromStr`
assert_eq!("3".parse::<F>(), Ok(F(3)));

// `Deref`
assert_eq!(*F(3), 3);
assert_eq!(F(3).to_i64(), Some(3i64));
assert_eq!(F(3).to_biguint(), 3u64.to_biguint());
assert_eq!(F(3).to_bigint(), 3u64.to_bigint());

// `Neg`
assert_eq!(-F(1), F(6));

// `Add`, `Sub`, `Mul`, `Div`, `Rem`
assert_eq!(F(3) + F(4), F(0));
assert_eq!(F(3) - F(4), F(6));
assert_eq!(F(3) * F(4), F(5));
assert_eq!(F(3) / F(4), F(6));
(0..=6).for_each(|x| (1..=6).for_each(|y| assert_eq!(F(x) % F(y), F(0))));

// `Num`
assert_eq!(F::from_str_radix("111", 2), Ok(F(0)));

// `Zero`, `One`
assert_eq!(F::zero(), F(0));
assert_eq!(F::one(), F(1));

// `FromPrimitive`
assert_eq!(F::from_i64(-1), Some(F::from(-1i64)));

// `Inv`
assert_eq!(F(3).inv(), F(5));

// `CheckedNeg`
(0..=6).for_each(|x| assert!(F(x).checked_neg().is_some()));

// `CheckedAdd`, `CheckedSub`, `CheckedMul`, `CheckedDiv`, `CheckedRem`
(0..=6).for_each(|x| (0..=6).for_each(|y| assert!(F(x).checked_add(&F(y)).is_some())));
assert_eq!(
    num::range_step(F(0), F(6), F(2)).collect::<Vec<_>>(),
    &[F(0), F(2), F(4)],
);
(0..=6).for_each(|x| (0..=6).for_each(|y| assert!(F(x).checked_sub(&F(y)).is_some())));
(0..=6).for_each(|x| (0..=6).for_each(|y| assert!(F(x).checked_mul(&F(y)).is_some())));
(0..=6).for_each(|x| (1..=6).for_each(|y| assert!(F(x).checked_div(&F(y)).is_some())));
(0..=6).for_each(|x| assert!(F(x).checked_div(&F(0)).is_none()));
(0..=6).for_each(|x| (1..=6).for_each(|y| assert!(F(x).checked_rem(&F(y)).is_some())));
(0..=6).for_each(|x| assert!(F(x).checked_rem(&F(0)).is_none()));

// `Pow`
assert_eq!(F(3).pow(2u8), F(2));
assert_eq!(F(3).pow(2u16), F(2));
assert_eq!(F(3).pow(2u32), F(2));
assert_eq!(F(3).pow(2u64), F(2));
assert_eq!(F(3).pow(2u128), F(2));
assert_eq!(F(3).pow(2usize), F(2));
assert_eq!(F(3).pow(-2i8), F(4));
assert_eq!(F(3).pow(-2i16), F(4));
assert_eq!(F(3).pow(-2i32), F(4));
assert_eq!(F(3).pow(-2i64), F(4));
assert_eq!(F(3).pow(-2i128), F(4));
assert_eq!(F(3).pow(-2isize), F(4));

Implementations

impl<C: Cartridge, M: ConstValue<Value = C::Target>> ModType<C, M>

pub fn modulus() -> C::Target

Gets the modulus.

pub fn new(value: C::Target) -> Self

Creates a new ModType.

pub fn new_unchecked(value: C::Target) -> Self

Creates a new ModType without checking value.

pub fn get_mut_unchecked(&mut self) -> &mut C::Target

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 sqrt(self) -> Option<Self>

where C: Cartridge<PartialMultiplication = True>,

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

Trait Implementations

impl<C, M: ConstValue<Value = C::Target>> Add<&BigInt> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&BigInt> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&BigUint> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&BigUint> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&ModType<C, M>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&ModType<C, M>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&Ratio<BigInt>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&Ratio<BigInt>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&Ratio<BigUint>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&Ratio<BigUint>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&f32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&f32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&f64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&f64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&i128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&i128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&i16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&i16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&i32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&i32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&i64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&i64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&i8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&i8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&isize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&isize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&u128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&u128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&u16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&u16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&u32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&u32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&u64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&u64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&u8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&u8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&usize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<&usize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<BigInt> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<BigInt> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<BigUint> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<BigUint> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<ModType<C, M>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<Ratio<BigInt>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<Ratio<BigInt>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<Ratio<BigUint>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<Ratio<BigUint>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<f32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<f32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<f64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<f64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<i128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<i128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<i16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<i16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<i32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<i32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<i64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<i64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<i8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<i8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<isize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<isize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<u128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<u128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<u16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<u16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<u32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<u32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<u64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<u64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<u8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<u8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<usize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add<usize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> Add for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&BigInt> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&BigUint> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&ModType<C, M>> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&Ratio<BigInt>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> AddAssign<&Ratio<BigUint>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> AddAssign<&f32> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> AddAssign<&f64> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> AddAssign<&i128> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&i16> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&i32> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&i64> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&i8> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&isize> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&u128> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&u16> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&u32> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&u64> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&u8> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<&usize> for ModType<C, M>

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

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

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<BigInt> for ModType<C, M>

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

fn add_assign(&mut self, rhs: BigInt)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<BigUint> for ModType<C, M>

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

fn add_assign(&mut self, rhs: BigUint)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<Ratio<BigInt>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> AddAssign<Ratio<BigUint>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> AddAssign<f32> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> AddAssign<f64> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> AddAssign<i128> for ModType<C, M>

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

fn add_assign(&mut self, rhs: i128)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<i16> for ModType<C, M>

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

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<i32> for ModType<C, M>

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

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<i64> for ModType<C, M>

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

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<i8> for ModType<C, M>

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

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<isize> for ModType<C, M>

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

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<u128> for ModType<C, M>

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

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<u16> for ModType<C, M>

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

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<u32> for ModType<C, M>

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

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<u64> for ModType<C, M>

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

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<u8> for ModType<C, M>

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

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign<usize> for ModType<C, M>

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

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> AddAssign for ModType<C, M>

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

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<C, M: ConstValue<Value = C::Target>> CheckedAdd for ModType<C, M>

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, M: ConstValue<Value = C::Target>> CheckedDiv for ModType<C, M>

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, M: ConstValue<Value = C::Target>> CheckedMul for ModType<C, M>

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, M: ConstValue<Value = C::Target>> CheckedNeg for ModType<C, M>

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, M: ConstValue<Value = C::Target>> CheckedRem for ModType<C, M>

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, M: ConstValue<Value = C::Target>> CheckedSub for ModType<C, M>

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, M: ConstValue<Value = C::Target>> Clone for ModType<C, M>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Cartridge, M: ConstValue<Value = C::Target>> Debug for ModType<C, M>

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

Formats the value using the given formatter.

impl<C: Cartridge, M: ConstValue<Value = C::Target>> Default for ModType<C, M>

fn default() -> Self

Returns the “default value” for a type.

impl<C, M: ConstValue<Value = C::Target>> Deref for ModType<C, M>

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, M: ConstValue<Value = C::Target>> Display for ModType<C, M>

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

Formats the value using the given formatter.

impl<C, M: ConstValue<Value = C::Target>> Div<&BigInt> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&BigInt> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&BigUint> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&BigUint> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&ModType<C, M>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&ModType<C, M>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&Ratio<BigInt>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&Ratio<BigInt>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&Ratio<BigUint>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&Ratio<BigUint>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&f32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&f32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&f64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&f64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&i128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&i128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&i16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&i16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&i32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&i32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&i64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&i64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&i8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&i8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&isize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&isize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&u128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&u128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&u16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&u16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&u32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&u32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&u64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&u64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&u8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&u8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&usize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<&usize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<BigInt> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<BigInt> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<BigUint> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<BigUint> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<ModType<C, M>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<Ratio<BigInt>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<Ratio<BigInt>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<Ratio<BigUint>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<Ratio<BigUint>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<f32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<f32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<f64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<f64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<i128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<i128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<i16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<i16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<i32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<i32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<i64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<i64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<i8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<i8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<isize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<isize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<u128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<u128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<u16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<u16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<u32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<u32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<u64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<u64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<u8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<u8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<usize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div<usize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> Div for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&BigInt> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&BigUint> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&ModType<C, M>> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&Ratio<BigInt>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> DivAssign<&Ratio<BigUint>> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&f32> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> DivAssign<&f64> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> DivAssign<&i128> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&i16> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&i32> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&i64> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&i8> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&isize> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&u128> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&u16> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&u32> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&u64> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&u8> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<&usize> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<BigInt> for ModType<C, M>

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

fn div_assign(&mut self, rhs: BigInt)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<BigUint> for ModType<C, M>

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

fn div_assign(&mut self, rhs: BigUint)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<Ratio<BigInt>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> DivAssign<Ratio<BigUint>> for ModType<C, M>

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

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

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<f32> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> DivAssign<f64> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> DivAssign<i128> for ModType<C, M>

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

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<i16> for ModType<C, M>

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

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<i32> for ModType<C, M>

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

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<i64> for ModType<C, M>

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

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<i8> for ModType<C, M>

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

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<isize> for ModType<C, M>

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

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<u128> for ModType<C, M>

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

fn div_assign(&mut self, rhs: u128)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<u16> for ModType<C, M>

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

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<u32> for ModType<C, M>

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

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<u64> for ModType<C, M>

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

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<u8> for ModType<C, M>

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

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign<usize> for ModType<C, M>

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

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> DivAssign for ModType<C, M>

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

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<C, M: ConstValue<Value = C::Target>> From<BigInt> for ModType<C, M>

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

fn from(from: BigInt) -> Self

Converts to this type from the input type.

impl<C: Cartridge, M: ConstValue<Value = C::Target>> From<BigUint> for ModType<C, M>

fn from(from: BigUint) -> Self

Converts to this type from the input type.

impl<C, M: ConstValue<Value = C::Target>> From<Ratio<BigInt>> for ModType<C, M>

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

fn from(from: Ratio<BigInt>) -> Self

Converts to this type from the input type.

impl<C, M: ConstValue<Value = C::Target>> From<Ratio<BigUint>> for ModType<C, M>

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

fn from(from: Ratio<BigUint>) -> Self

Converts to this type from the input type.

impl<C, M: ConstValue<Value = C::Target>> From<f32> for ModType<C, M>

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

fn from(from: f32) -> Self

Converts to this type from the input type.

impl<C, M: ConstValue<Value = C::Target>> From<f64> for ModType<C, M>

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

fn from(from: f64) -> Self

Converts to this type from the input type.

impl<C, M: ConstValue<Value = C::Target>> From<i128> for ModType<C, M>

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

fn from(from: i128) -> Self

Converts to this type from the input type.

impl<C, M: ConstValue<Value = C::Target>> From<i16> for ModType<C, M>

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

fn from(from: i16) -> Self

Converts to this type from the input type.

impl<C, M: ConstValue<Value = C::Target>> From<i32> for ModType<C, M>

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

fn from(from: i32) -> Self

Converts to this type from the input type.

impl<C, M: ConstValue<Value = C::Target>> From<i64> for ModType<C, M>

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

fn from(from: i64) -> Self

Converts to this type from the input type.

impl<C, M: ConstValue<Value = C::Target>> From<i8> for ModType<C, M>

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

fn from(from: i8) -> Self

Converts to this type from the input type.

impl<C, M: ConstValue<Value = C::Target>> From<isize> for ModType<C, M>

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

fn from(from: isize) -> Self

Converts to this type from the input type.

impl<C: Cartridge, M: ConstValue<Value = C::Target>> From<u128> for ModType<C, M>

fn from(from: u128) -> Self

Converts to this type from the input type.

impl<C: Cartridge, M: ConstValue<Value = C::Target>> From<u16> for ModType<C, M>

fn from(from: u16) -> Self

Converts to this type from the input type.

impl<C: Cartridge, M: ConstValue<Value = C::Target>> From<u32> for ModType<C, M>

fn from(from: u32) -> Self

Converts to this type from the input type.

impl<C: Cartridge, M: ConstValue<Value = C::Target>> From<u64> for ModType<C, M>

fn from(from: u64) -> Self

Converts to this type from the input type.

impl<C: Cartridge, M: ConstValue<Value = C::Target>> From<u8> for ModType<C, M>

fn from(from: u8) -> Self

Converts to this type from the input type.

impl<C: Cartridge, M: ConstValue<Value = C::Target>> From<usize> for ModType<C, M>

fn from(from: usize) -> Self

Converts to this type from the input type.

impl<C, M: ConstValue<Value = C::Target>> FromPrimitive for ModType<C, M>

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

fn from_i64(value: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(value: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(value: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(value: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(value: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(value: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(value: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(value: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(value: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(value: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(value: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(value: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(value: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(value: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl<C: Cartridge, M: ConstValue<Value = C::Target>> FromStr for ModType<C, M>

type Err = ParseIntError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, ParseIntError>

Parses a string s to return a value of this type.

impl<C, M: ConstValue<Value = C::Target>> Inv for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn inv(self) -> ModType<C, M>

Returns the multiplicative inverse of self.

impl<C, M: ConstValue<Value = C::Target>> Inv for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn inv(self) -> ModType<C, M>

Returns the multiplicative inverse of self.

impl<C, M: ConstValue<Value = C::Target>> Mul<&BigInt> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&BigInt> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&BigUint> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&BigUint> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&ModType<C, M>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&ModType<C, M>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&Ratio<BigInt>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&Ratio<BigInt>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&Ratio<BigUint>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&Ratio<BigUint>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&f32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&f32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&f64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&f64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&i128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&i128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&i16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&i16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&i32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&i32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&i64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&i64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&i8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&i8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&isize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&isize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&u128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&u128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&u16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&u16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&u32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&u32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&u64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&u64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&u8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&u8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&usize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<&usize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<BigInt> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<BigInt> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<BigUint> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<BigUint> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<ModType<C, M>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<Ratio<BigInt>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<Ratio<BigInt>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<Ratio<BigUint>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<Ratio<BigUint>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<f32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<f32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<f64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<f64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<i128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<i128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<i16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<i16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<i32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<i32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<i64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<i64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<i8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<i8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<isize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<isize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<u128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<u128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<u16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<u16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<u32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<u32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<u64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<u64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<u8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<u8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<usize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul<usize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> Mul for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&BigInt> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&BigUint> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&ModType<C, M>> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&Ratio<BigInt>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> MulAssign<&Ratio<BigUint>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> MulAssign<&f32> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> MulAssign<&f64> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> MulAssign<&i128> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&i16> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&i32> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&i64> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&i8> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&isize> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&u128> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&u16> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&u32> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&u64> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&u8> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<&usize> for ModType<C, M>

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

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

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<BigInt> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: BigInt)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<BigUint> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: BigUint)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<Ratio<BigInt>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> MulAssign<Ratio<BigUint>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> MulAssign<f32> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> MulAssign<f64> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> MulAssign<i128> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<i16> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<i32> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<i64> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<i8> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<isize> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: isize)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<u128> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: u128)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<u16> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<u32> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<u64> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<u8> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign<usize> for ModType<C, M>

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

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> MulAssign for ModType<C, M>

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

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<C, M: ConstValue<Value = C::Target>> Neg for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn neg(self) -> ModType<C, M>

Performs the unary - operation.

impl<C, M: ConstValue<Value = C::Target>> Neg for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<C, M: ConstValue<Value = C::Target>> Num for ModType<C, M>

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

type FromStrRadixErr = ParseIntError

fn from_str_radix(str: &str, radix: u32) -> Result<Self, ParseIntError>

Convert from a string and radix (typically 2..=36).

impl<C, M: ConstValue<Value = C::Target>> One for ModType<C, M>

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

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<C, M: ConstValue<Value = C::Target>> Ord for ModType<C, M>

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, M: ConstValue<Value = C::Target>> PartialEq for ModType<C, M>

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, M: ConstValue<Value = C::Target>> PartialOrd for ModType<C, M>

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, M: ConstValue<Value = C::Target>> Pow<&i128> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &i128) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&i128> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &i128) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&i16> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &i16) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&i16> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &i16) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&i32> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &i32) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&i32> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &i32) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&i64> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &i64) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&i64> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &i64) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&i8> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &i8) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&i8> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &i8) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&isize> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &isize) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&isize> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &isize) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&u128> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &u128) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&u128> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &u128) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&u16> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &u16) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&u16> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &u16) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&u32> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &u32) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&u32> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &u32) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&u64> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &u64) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&u64> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &u64) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&u8> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &u8) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&u8> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &u8) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&usize> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &usize) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<&usize> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: &usize) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<i128> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: i128) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<i128> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: i128) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<i16> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: i16) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<i16> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: i16) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<i32> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: i32) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<i32> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: i32) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<i64> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: i64) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<i64> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: i64) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<i8> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: i8) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<i8> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: i8) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<isize> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: isize) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<isize> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: isize) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<u128> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: u128) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<u128> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: u128) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<u16> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: u16) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<u16> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: u16) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<u32> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: u32) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<u32> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: u32) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<u64> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: u64) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<u64> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: u64) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<u8> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: u8) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<u8> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: u8) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<usize> for &ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: usize) -> ModType<C, M>

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Pow<usize> for ModType<C, M>

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

type Output = ModType<C, M>

The result after applying the operator.

fn pow(self, exp: usize) -> Self

Returns self to the power rhs.

impl<C, M: ConstValue<Value = C::Target>> Rem<&BigInt> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&BigInt> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&BigUint> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&BigUint> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&ModType<C, M>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&ModType<C, M>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&Ratio<BigInt>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&Ratio<BigInt>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&Ratio<BigUint>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&Ratio<BigUint>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&f32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&f32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&f64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&f64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&i128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&i128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&i16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&i16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&i32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&i32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&i64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&i64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&i8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&i8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&isize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&isize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&u128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&u128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&u16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&u16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&u32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&u32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&u64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&u64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&u8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&u8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&usize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<&usize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<BigInt> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<BigInt> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<BigUint> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<BigUint> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<ModType<C, M>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<Ratio<BigInt>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<Ratio<BigInt>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<Ratio<BigUint>> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<Ratio<BigUint>> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<f32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<f32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<f64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<f64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<i128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<i128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<i16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<i16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<i32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<i32> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<i64> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<i64> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<i8> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<i8> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<isize> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<isize> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<u128> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<u128> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<u16> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<u16> for ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<u32> for &ModType<C, M>

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

type Output = ModType<C, M>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> ModType<C, M>

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<u32> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> ModType<C, M>

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<u64> for &ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> ModType<C, M>

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<u64> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> ModType<C, M>

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<u8> for &ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> ModType<C, M>

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<u8> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> ModType<C, M>

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<usize> for &ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the % operator.

fn rem(self, rhs: usize) -> ModType<C, M>

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem<usize> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the % operator.

fn rem(self, rhs: usize) -> ModType<C, M>

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> Rem for ModType<C, M>

where C: Cartridge<PartialDivision = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the % operator.

fn rem(self, rhs: ModType<C, M>) -> ModType<C, M>

Performs the % operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&BigInt> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &BigInt)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&BigUint> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &BigUint)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&ModType<C, M>> for ModType<C, M>

where C: Cartridge<PartialDivision = True> + Cartridge,

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&Ratio<BigInt>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> RemAssign<&Ratio<BigUint>> for ModType<C, M>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &Ratio<BigUint>)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&f32> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> RemAssign<&f64> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> RemAssign<&i128> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &i128)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&i16> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &i16)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&i32> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &i32)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&i64> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &i64)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&i8> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &i8)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&isize> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &isize)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&u128> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &u128)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&u16> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &u16)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&u32> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &u32)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&u64> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &u64)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&u8> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &u8)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<&usize> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: &usize)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<BigInt> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: BigInt)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<BigUint> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: BigUint)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<Ratio<BigInt>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> RemAssign<Ratio<BigUint>> for ModType<C, M>

where C: Cartridge<PartialDivision = True, AssumePrimeModulus = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: Ratio<BigUint>)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<f32> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> RemAssign<f64> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> RemAssign<i128> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: i128)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<i16> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: i16)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<i32> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<i64> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: i64)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<i8> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: i8)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<isize> for ModType<C, M>

where C: Cartridge<PartialDivision = True, PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: isize)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<u128> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: u128)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<u16> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: u16)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<u32> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<u64> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: u64)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<u8> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: u8)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign<usize> for ModType<C, M>

where C: Cartridge<PartialDivision = True, FlexibleRhs = True> + Cartridge,

fn rem_assign(&mut self, rhs: usize)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> RemAssign for ModType<C, M>

where C: Cartridge<PartialDivision = True> + Cartridge,

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&BigInt> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &BigInt) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&BigInt> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &BigInt) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&BigUint> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &BigUint) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&BigUint> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &BigUint) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&ModType<C, M>> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &ModType<C, M>) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&ModType<C, M>> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &ModType<C, M>) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&Ratio<BigInt>> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ratio<BigInt>) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&Ratio<BigInt>> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ratio<BigInt>) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&Ratio<BigUint>> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ratio<BigUint>) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&Ratio<BigUint>> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ratio<BigUint>) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&f32> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &f32) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&f32> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &f32) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&f64> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &f64) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&f64> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &f64) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&i128> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&i128> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&i16> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&i16> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&i32> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&i32> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&i64> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&i64> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&i8> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&i8> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&isize> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&isize> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&u128> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&u128> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&u16> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&u16> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&u32> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&u32> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&u64> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&u64> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&u8> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&u8> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&usize> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<&usize> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<BigInt> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: BigInt) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<BigInt> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: BigInt) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<BigUint> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: BigUint) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<BigUint> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: BigUint) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<ModType<C, M>> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: ModType<C, M>) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<Ratio<BigInt>> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: Ratio<BigInt>) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<Ratio<BigInt>> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: Ratio<BigInt>) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<Ratio<BigUint>> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: Ratio<BigUint>) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<Ratio<BigUint>> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: Ratio<BigUint>) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<f32> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<f32> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<f64> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<f64> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, AssumePrimeModulus = True, PartialMultiplication = True, PartialDivision = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<i128> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<i128> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<i16> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<i16> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<i32> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<i32> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<i64> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<i64> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<i8> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<i8> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<isize> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<isize> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<u128> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<u128> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<u16> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<u16> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<u32> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<u32> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<u64> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<u64> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<u8> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<u8> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<usize> for &ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub<usize> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> Sub for ModType<C, M>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

type Output = ModType<C, M>

The resulting type after applying the - operator.

fn sub(self, rhs: ModType<C, M>) -> ModType<C, M>

Performs the - operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&BigInt> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &BigInt)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&BigUint> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &BigUint)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&ModType<C, M>> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&Ratio<BigInt>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> SubAssign<&Ratio<BigUint>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> SubAssign<&f32> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> SubAssign<&f64> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> SubAssign<&i128> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &i128)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&i16> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &i16)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&i32> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &i32)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&i64> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &i64)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&i8> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &i8)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&isize> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &isize)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&u128> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &u128)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&u16> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &u16)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&u32> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &u32)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&u64> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &u64)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&u8> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &u8)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<&usize> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: &usize)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<BigInt> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: BigInt)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<BigUint> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: BigUint)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<Ratio<BigInt>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> SubAssign<Ratio<BigUint>> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> SubAssign<f32> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> SubAssign<f64> for ModType<C, M>

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, M: ConstValue<Value = C::Target>> SubAssign<i128> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: i128)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<i16> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<i32> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<i64> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<i8> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<isize> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<u128> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<u16> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<u32> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<u64> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<u8> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign<usize> for ModType<C, M>

where C: Cartridge<PartialSubtraction = True, FlexibleRhs = True> + Cartridge,

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> SubAssign for ModType<C, M>

where C: Cartridge<PartialSubtraction = True> + Cartridge,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<C, M: ConstValue<Value = C::Target>> Zero for ModType<C, M>

where C: Cartridge<PartialAddition = True> + Cartridge,

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<C: Cartridge, M: ConstValue<Value = C::Target>> Copy for ModType<C, M>

impl<C, M: ConstValue<Value = C::Target>> Eq for ModType<C, M>

where C: Cartridge<Equality = True> + Cartridge,