Struct IntMod

pub struct IntMod { /* private fields */ }

Implementations

impl IntMod

pub fn zero(ctx: &IntModCtx) -> IntMod

pub fn one(ctx: &IntModCtx) -> IntMod

pub fn zero_assign(&mut self)

pub fn one_assign(&mut self)

pub const fn as_ptr(&self) -> *const fmpz

Returns a pointer to the inner FLINT integer.

pub fn as_mut_ptr(&mut self) -> *mut fmpz

Returns a mutable pointer to the inner FLINT integer.

pub fn ctx_as_ptr(&self) -> *const fmpz_mod_ctx_struct

Returns a pointer to the FLINT context.

pub fn modulus_as_ptr(&self) -> *const fmpz

Returns a pointer to the FLINT context.

pub const unsafe fn from_raw(inner: fmpz, ctx: IntModCtx) -> IntMod

Construct an IntMod from a raw fmpz::fmpz and reference to an IntModRing. This does not canonicalize the output!

pub const fn into_raw(self) -> fmpz

pub const fn context(&self) -> &IntModCtx

pub fn modulus(&self) -> Integer

Return the modulus of IntMod.

pub fn is_zero(&self) -> bool

pub fn is_one(&self) -> bool

Trait Implementations

impl Add<&IntMod> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for &Integer

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for &Rational

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for &i16

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for &i32

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for &i64

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for &i8

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for &u16

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for &u32

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for &u64

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for &u8

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for Integer

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for Rational

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for i16

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for i32

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for i64

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for i8

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for u16

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for u32

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for u64

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&IntMod> for u8

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &IntMod) -> IntMod

Performs the + operation.

impl Add<&Integer> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> IntMod

Performs the + operation.

impl Add<&Integer> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> IntMod

Performs the + operation.

impl Add<&Rational> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> IntMod

Performs the + operation.

impl Add<&Rational> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> IntMod

Performs the + operation.

impl Add<&i16> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> IntMod

Performs the + operation.

impl Add<&i16> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> IntMod

Performs the + operation.

impl Add<&i32> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> IntMod

Performs the + operation.

impl Add<&i32> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> IntMod

Performs the + operation.

impl Add<&i64> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> IntMod

Performs the + operation.

impl Add<&i64> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> IntMod

Performs the + operation.

impl Add<&i8> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> IntMod

Performs the + operation.

impl Add<&i8> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> IntMod

Performs the + operation.

impl Add<&u16> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> IntMod

Performs the + operation.

impl Add<&u16> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> IntMod

Performs the + operation.

impl Add<&u32> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> IntMod

Performs the + operation.

impl Add<&u32> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> IntMod

Performs the + operation.

impl Add<&u64> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> IntMod

Performs the + operation.

impl Add<&u64> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> IntMod

Performs the + operation.

impl Add<&u8> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> IntMod

Performs the + operation.

impl Add<&u8> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> IntMod

Performs the + operation.

impl Add<IntMod> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for &Integer

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for &Rational

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for &i16

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for &i32

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for &i64

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for &i8

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for &u16

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for &u32

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for &u64

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for &u8

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for Integer

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for Rational

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for i16

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for i32

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for i64

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for i8

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for u16

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for u32

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for u64

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<IntMod> for u8

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl Add<Integer> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: Integer) -> IntMod

Performs the + operation.

impl Add<Integer> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: Integer) -> IntMod

Performs the + operation.

impl Add<Rational> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: Rational) -> IntMod

Performs the + operation.

impl Add<Rational> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: Rational) -> IntMod

Performs the + operation.

impl Add<i16> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> IntMod

Performs the + operation.

impl Add<i16> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> IntMod

Performs the + operation.

impl Add<i32> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> IntMod

Performs the + operation.

impl Add<i32> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> IntMod

Performs the + operation.

impl Add<i64> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> IntMod

Performs the + operation.

impl Add<i64> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> IntMod

Performs the + operation.

impl Add<i8> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> IntMod

Performs the + operation.

impl Add<i8> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> IntMod

Performs the + operation.

impl Add<u16> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> IntMod

Performs the + operation.

impl Add<u16> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> IntMod

Performs the + operation.

impl Add<u32> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> IntMod

Performs the + operation.

impl Add<u32> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> IntMod

Performs the + operation.

impl Add<u64> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> IntMod

Performs the + operation.

impl Add<u64> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> IntMod

Performs the + operation.

impl Add<u8> for &IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> IntMod

Performs the + operation.

impl Add<u8> for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> IntMod

Performs the + operation.

impl Add for IntMod

type Output = IntMod

The resulting type after applying the + operator.

fn add(self, rhs: IntMod) -> IntMod

Performs the + operation.

impl AddAssign<&IntMod> for IntMod

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

Performs the += operation.

impl AddAssign<&Integer> for IntMod

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

Performs the += operation.

impl AddAssign<&Rational> for IntMod

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

Performs the += operation.

impl AddAssign<&i16> for IntMod

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

Performs the += operation.

impl AddAssign<&i32> for IntMod

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

Performs the += operation.

impl AddAssign<&i64> for IntMod

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

Performs the += operation.

impl AddAssign<&i8> for IntMod

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

Performs the += operation.

impl AddAssign<&u16> for IntMod

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

Performs the += operation.

impl AddAssign<&u32> for IntMod

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

Performs the += operation.

impl AddAssign<&u64> for IntMod

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

Performs the += operation.

impl AddAssign<&u8> for IntMod

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

Performs the += operation.

impl AddAssign<Integer> for IntMod

fn add_assign(&mut self, rhs: Integer)

Performs the += operation.

impl AddAssign<Rational> for IntMod

fn add_assign(&mut self, rhs: Rational)

Performs the += operation.

impl AddAssign<i16> for IntMod

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl AddAssign<i32> for IntMod

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl AddAssign<i64> for IntMod

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl AddAssign<i8> for IntMod

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl AddAssign<u16> for IntMod

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl AddAssign<u32> for IntMod

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl AddAssign<u64> for IntMod

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl AddAssign<u8> for IntMod

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl AddAssign for IntMod

fn add_assign(&mut self, rhs: IntMod)

Performs the += operation.

impl AddFrom<&IntMod> for IntMod

fn add_from(&mut self, lhs: &IntMod)

impl AddFrom<&Integer> for IntMod

fn add_from(&mut self, lhs: &Integer)

impl AddFrom<&Rational> for IntMod

fn add_from(&mut self, lhs: &Rational)

impl AddFrom<&i16> for IntMod

fn add_from(&mut self, lhs: &i16)

impl AddFrom<&i32> for IntMod

fn add_from(&mut self, lhs: &i32)

impl AddFrom<&i64> for IntMod

fn add_from(&mut self, lhs: &i64)

impl AddFrom<&i8> for IntMod

fn add_from(&mut self, lhs: &i8)

impl AddFrom<&u16> for IntMod

fn add_from(&mut self, lhs: &u16)

impl AddFrom<&u32> for IntMod

fn add_from(&mut self, lhs: &u32)

impl AddFrom<&u64> for IntMod

fn add_from(&mut self, lhs: &u64)

impl AddFrom<&u8> for IntMod

fn add_from(&mut self, lhs: &u8)

impl AddFrom<Integer> for IntMod

fn add_from(&mut self, lhs: Integer)

impl AddFrom<Rational> for IntMod

fn add_from(&mut self, lhs: Rational)

impl AddFrom<i16> for IntMod

fn add_from(&mut self, lhs: i16)

impl AddFrom<i32> for IntMod

fn add_from(&mut self, lhs: i32)

impl AddFrom<i64> for IntMod

fn add_from(&mut self, lhs: i64)

impl AddFrom<i8> for IntMod

fn add_from(&mut self, lhs: i8)

impl AddFrom<u16> for IntMod

fn add_from(&mut self, lhs: u16)

impl AddFrom<u32> for IntMod

fn add_from(&mut self, lhs: u32)

impl AddFrom<u64> for IntMod

fn add_from(&mut self, lhs: u64)

impl AddFrom<u8> for IntMod

fn add_from(&mut self, lhs: u8)

impl AddFrom for IntMod

fn add_from(&mut self, lhs: IntMod)

impl AsRef<IntMod> for IntMod

fn as_ref(&self) -> &IntMod

Converts this type into a shared reference of the (usually inferred) input type.

impl Assign<&IntMod> for IntMod

fn assign(&mut self, src: &IntMod)

impl Assign<&IntMod> for IntPoly

fn assign(&mut self, src: &IntMod)

impl Assign<&IntMod> for RatPoly

fn assign(&mut self, src: &IntMod)

impl Assign<&Integer> for IntMod

fn assign(&mut self, src: &Integer)

impl Assign<&Rational> for IntMod

fn assign(&mut self, src: &Rational)

impl Assign<&i16> for IntMod

fn assign(&mut self, src: &i16)

impl Assign<&i32> for IntMod

fn assign(&mut self, src: &i32)

impl Assign<&i64> for IntMod

fn assign(&mut self, src: &i64)

impl Assign<&i8> for IntMod

fn assign(&mut self, src: &i8)

impl Assign<&u16> for IntMod

fn assign(&mut self, src: &u16)

impl Assign<&u32> for IntMod

fn assign(&mut self, src: &u32)

impl Assign<&u64> for IntMod

fn assign(&mut self, src: &u64)

impl Assign<&u8> for IntMod

fn assign(&mut self, src: &u8)

impl Assign<IntMod> for IntPoly

fn assign(&mut self, src: IntMod)

impl Assign<IntMod> for RatPoly

fn assign(&mut self, src: IntMod)

impl Assign<Integer> for IntMod

fn assign(&mut self, src: Integer)

impl Assign<Rational> for IntMod

fn assign(&mut self, src: Rational)

impl Assign<i16> for IntMod

fn assign(&mut self, src: i16)

impl Assign<i32> for IntMod

fn assign(&mut self, src: i32)

impl Assign<i64> for IntMod

fn assign(&mut self, src: i64)

impl Assign<i8> for IntMod

fn assign(&mut self, src: i8)

impl Assign<u16> for IntMod

fn assign(&mut self, src: u16)

impl Assign<u32> for IntMod

fn assign(&mut self, src: u32)

impl Assign<u64> for IntMod

fn assign(&mut self, src: u64)

impl Assign<u8> for IntMod

fn assign(&mut self, src: u8)

impl Assign for IntMod

fn assign(&mut self, src: IntMod)

impl AssignAdd<&IntMod> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: IntMod)

impl AssignAdd<&IntMod, &IntMod> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: &IntMod)

impl AssignAdd<&IntMod, &Integer> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: &Integer)

impl AssignAdd<&IntMod, &Rational> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: &Rational)

impl AssignAdd<&IntMod, &i16> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: &i16)

impl AssignAdd<&IntMod, &i32> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: &i32)

impl AssignAdd<&IntMod, &i64> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: &i64)

impl AssignAdd<&IntMod, &i8> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: &i8)

impl AssignAdd<&IntMod, &u16> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: &u16)

impl AssignAdd<&IntMod, &u32> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: &u32)

impl AssignAdd<&IntMod, &u64> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: &u64)

impl AssignAdd<&IntMod, &u8> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: &u8)

impl AssignAdd<&IntMod, Integer> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: Integer)

impl AssignAdd<&IntMod, Rational> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: Rational)

impl AssignAdd<&IntMod, i16> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: i16)

impl AssignAdd<&IntMod, i32> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: i32)

impl AssignAdd<&IntMod, i64> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: i64)

impl AssignAdd<&IntMod, i8> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: i8)

impl AssignAdd<&IntMod, u16> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: u16)

impl AssignAdd<&IntMod, u32> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: u32)

impl AssignAdd<&IntMod, u64> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: u64)

impl AssignAdd<&IntMod, u8> for IntMod

fn assign_add(&mut self, lhs: &IntMod, rhs: u8)

impl AssignAdd<&Integer> for IntMod

fn assign_add(&mut self, lhs: &Integer, rhs: IntMod)

impl AssignAdd<&Integer, &IntMod> for IntMod

fn assign_add(&mut self, lhs: &Integer, rhs: &IntMod)

impl AssignAdd<&Rational> for IntMod

fn assign_add(&mut self, lhs: &Rational, rhs: IntMod)

impl AssignAdd<&Rational, &IntMod> for IntMod

fn assign_add(&mut self, lhs: &Rational, rhs: &IntMod)

impl AssignAdd<&i16> for IntMod

fn assign_add(&mut self, lhs: &i16, rhs: IntMod)

impl AssignAdd<&i16, &IntMod> for IntMod

fn assign_add(&mut self, lhs: &i16, rhs: &IntMod)

impl AssignAdd<&i32> for IntMod

fn assign_add(&mut self, lhs: &i32, rhs: IntMod)

impl AssignAdd<&i32, &IntMod> for IntMod

fn assign_add(&mut self, lhs: &i32, rhs: &IntMod)

impl AssignAdd<&i64> for IntMod

fn assign_add(&mut self, lhs: &i64, rhs: IntMod)

impl AssignAdd<&i64, &IntMod> for IntMod

fn assign_add(&mut self, lhs: &i64, rhs: &IntMod)

impl AssignAdd<&i8> for IntMod

fn assign_add(&mut self, lhs: &i8, rhs: IntMod)

impl AssignAdd<&i8, &IntMod> for IntMod

fn assign_add(&mut self, lhs: &i8, rhs: &IntMod)

impl AssignAdd<&u16> for IntMod

fn assign_add(&mut self, lhs: &u16, rhs: IntMod)

impl AssignAdd<&u16, &IntMod> for IntMod

fn assign_add(&mut self, lhs: &u16, rhs: &IntMod)

impl AssignAdd<&u32> for IntMod

fn assign_add(&mut self, lhs: &u32, rhs: IntMod)

impl AssignAdd<&u32, &IntMod> for IntMod

fn assign_add(&mut self, lhs: &u32, rhs: &IntMod)

impl AssignAdd<&u64> for IntMod

fn assign_add(&mut self, lhs: &u64, rhs: IntMod)

impl AssignAdd<&u64, &IntMod> for IntMod

fn assign_add(&mut self, lhs: &u64, rhs: &IntMod)

impl AssignAdd<&u8> for IntMod

fn assign_add(&mut self, lhs: &u8, rhs: IntMod)

impl AssignAdd<&u8, &IntMod> for IntMod

fn assign_add(&mut self, lhs: &u8, rhs: &IntMod)

impl AssignAdd<IntMod, &IntMod> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: &IntMod)

impl AssignAdd<IntMod, &Integer> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: &Integer)

impl AssignAdd<IntMod, &Rational> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: &Rational)

impl AssignAdd<IntMod, &i16> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: &i16)

impl AssignAdd<IntMod, &i32> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: &i32)

impl AssignAdd<IntMod, &i64> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: &i64)

impl AssignAdd<IntMod, &i8> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: &i8)

impl AssignAdd<IntMod, &u16> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: &u16)

impl AssignAdd<IntMod, &u32> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: &u32)

impl AssignAdd<IntMod, &u64> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: &u64)

impl AssignAdd<IntMod, &u8> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: &u8)

impl AssignAdd<IntMod, Integer> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: Integer)

impl AssignAdd<IntMod, Rational> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: Rational)

impl AssignAdd<IntMod, i16> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: i16)

impl AssignAdd<IntMod, i32> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: i32)

impl AssignAdd<IntMod, i64> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: i64)

impl AssignAdd<IntMod, i8> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: i8)

impl AssignAdd<IntMod, u16> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: u16)

impl AssignAdd<IntMod, u32> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: u32)

impl AssignAdd<IntMod, u64> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: u64)

impl AssignAdd<IntMod, u8> for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: u8)

impl AssignAdd<Integer> for IntMod

fn assign_add(&mut self, lhs: Integer, rhs: IntMod)

impl AssignAdd<Integer, &IntMod> for IntMod

fn assign_add(&mut self, lhs: Integer, rhs: &IntMod)

impl AssignAdd<Rational> for IntMod

fn assign_add(&mut self, lhs: Rational, rhs: IntMod)

impl AssignAdd<Rational, &IntMod> for IntMod

fn assign_add(&mut self, lhs: Rational, rhs: &IntMod)

impl AssignAdd<i16> for IntMod

fn assign_add(&mut self, lhs: i16, rhs: IntMod)

impl AssignAdd<i16, &IntMod> for IntMod

fn assign_add(&mut self, lhs: i16, rhs: &IntMod)

impl AssignAdd<i32> for IntMod

fn assign_add(&mut self, lhs: i32, rhs: IntMod)

impl AssignAdd<i32, &IntMod> for IntMod

fn assign_add(&mut self, lhs: i32, rhs: &IntMod)

impl AssignAdd<i64> for IntMod

fn assign_add(&mut self, lhs: i64, rhs: IntMod)

impl AssignAdd<i64, &IntMod> for IntMod

fn assign_add(&mut self, lhs: i64, rhs: &IntMod)

impl AssignAdd<i8> for IntMod

fn assign_add(&mut self, lhs: i8, rhs: IntMod)

impl AssignAdd<i8, &IntMod> for IntMod

fn assign_add(&mut self, lhs: i8, rhs: &IntMod)

impl AssignAdd<u16> for IntMod

fn assign_add(&mut self, lhs: u16, rhs: IntMod)

impl AssignAdd<u16, &IntMod> for IntMod

fn assign_add(&mut self, lhs: u16, rhs: &IntMod)

impl AssignAdd<u32> for IntMod

fn assign_add(&mut self, lhs: u32, rhs: IntMod)

impl AssignAdd<u32, &IntMod> for IntMod

fn assign_add(&mut self, lhs: u32, rhs: &IntMod)

impl AssignAdd<u64> for IntMod

fn assign_add(&mut self, lhs: u64, rhs: IntMod)

impl AssignAdd<u64, &IntMod> for IntMod

fn assign_add(&mut self, lhs: u64, rhs: &IntMod)

impl AssignAdd<u8> for IntMod

fn assign_add(&mut self, lhs: u8, rhs: IntMod)

impl AssignAdd<u8, &IntMod> for IntMod

fn assign_add(&mut self, lhs: u8, rhs: &IntMod)

impl AssignAdd for IntMod

fn assign_add(&mut self, lhs: IntMod, rhs: IntMod)

impl AssignDiv<&IntMod> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: IntMod)

impl AssignDiv<&IntMod, &IntMod> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: &IntMod)

impl AssignDiv<&IntMod, &Integer> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: &Integer)

impl AssignDiv<&IntMod, &Rational> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: &Rational)

impl AssignDiv<&IntMod, &i16> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: &i16)

impl AssignDiv<&IntMod, &i32> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: &i32)

impl AssignDiv<&IntMod, &i64> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: &i64)

impl AssignDiv<&IntMod, &i8> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: &i8)

impl AssignDiv<&IntMod, &u16> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: &u16)

impl AssignDiv<&IntMod, &u32> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: &u32)

impl AssignDiv<&IntMod, &u64> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: &u64)

impl AssignDiv<&IntMod, &u8> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: &u8)

impl AssignDiv<&IntMod, Integer> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: Integer)

impl AssignDiv<&IntMod, Rational> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: Rational)

impl AssignDiv<&IntMod, i16> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: i16)

impl AssignDiv<&IntMod, i32> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: i32)

impl AssignDiv<&IntMod, i64> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: i64)

impl AssignDiv<&IntMod, i8> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: i8)

impl AssignDiv<&IntMod, u16> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: u16)

impl AssignDiv<&IntMod, u32> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: u32)

impl AssignDiv<&IntMod, u64> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: u64)

impl AssignDiv<&IntMod, u8> for IntMod

fn assign_div(&mut self, lhs: &IntMod, rhs: u8)

impl AssignDiv<&Integer> for IntMod

fn assign_div(&mut self, lhs: &Integer, rhs: IntMod)

impl AssignDiv<&Integer, &IntMod> for IntMod

fn assign_div(&mut self, lhs: &Integer, rhs: &IntMod)

impl AssignDiv<&Rational> for IntMod

fn assign_div(&mut self, lhs: &Rational, rhs: IntMod)

impl AssignDiv<&Rational, &IntMod> for IntMod

fn assign_div(&mut self, lhs: &Rational, rhs: &IntMod)

impl AssignDiv<&i16> for IntMod

fn assign_div(&mut self, lhs: &i16, rhs: IntMod)

impl AssignDiv<&i16, &IntMod> for IntMod

fn assign_div(&mut self, lhs: &i16, rhs: &IntMod)

impl AssignDiv<&i32> for IntMod

fn assign_div(&mut self, lhs: &i32, rhs: IntMod)

impl AssignDiv<&i32, &IntMod> for IntMod

fn assign_div(&mut self, lhs: &i32, rhs: &IntMod)

impl AssignDiv<&i64> for IntMod

fn assign_div(&mut self, lhs: &i64, rhs: IntMod)

impl AssignDiv<&i64, &IntMod> for IntMod

fn assign_div(&mut self, lhs: &i64, rhs: &IntMod)

impl AssignDiv<&i8> for IntMod

fn assign_div(&mut self, lhs: &i8, rhs: IntMod)

impl AssignDiv<&i8, &IntMod> for IntMod

fn assign_div(&mut self, lhs: &i8, rhs: &IntMod)

impl AssignDiv<&u16> for IntMod

fn assign_div(&mut self, lhs: &u16, rhs: IntMod)

impl AssignDiv<&u16, &IntMod> for IntMod

fn assign_div(&mut self, lhs: &u16, rhs: &IntMod)

impl AssignDiv<&u32> for IntMod

fn assign_div(&mut self, lhs: &u32, rhs: IntMod)

impl AssignDiv<&u32, &IntMod> for IntMod

fn assign_div(&mut self, lhs: &u32, rhs: &IntMod)

impl AssignDiv<&u64> for IntMod

fn assign_div(&mut self, lhs: &u64, rhs: IntMod)

impl AssignDiv<&u64, &IntMod> for IntMod

fn assign_div(&mut self, lhs: &u64, rhs: &IntMod)

impl AssignDiv<&u8> for IntMod

fn assign_div(&mut self, lhs: &u8, rhs: IntMod)

impl AssignDiv<&u8, &IntMod> for IntMod

fn assign_div(&mut self, lhs: &u8, rhs: &IntMod)

impl AssignDiv<IntMod, &IntMod> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: &IntMod)

impl AssignDiv<IntMod, &Integer> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: &Integer)

impl AssignDiv<IntMod, &Rational> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: &Rational)

impl AssignDiv<IntMod, &i16> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: &i16)

impl AssignDiv<IntMod, &i32> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: &i32)

impl AssignDiv<IntMod, &i64> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: &i64)

impl AssignDiv<IntMod, &i8> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: &i8)

impl AssignDiv<IntMod, &u16> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: &u16)

impl AssignDiv<IntMod, &u32> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: &u32)

impl AssignDiv<IntMod, &u64> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: &u64)

impl AssignDiv<IntMod, &u8> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: &u8)

impl AssignDiv<IntMod, Integer> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: Integer)

impl AssignDiv<IntMod, Rational> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: Rational)

impl AssignDiv<IntMod, i16> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: i16)

impl AssignDiv<IntMod, i32> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: i32)

impl AssignDiv<IntMod, i64> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: i64)

impl AssignDiv<IntMod, i8> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: i8)

impl AssignDiv<IntMod, u16> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: u16)

impl AssignDiv<IntMod, u32> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: u32)

impl AssignDiv<IntMod, u64> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: u64)

impl AssignDiv<IntMod, u8> for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: u8)

impl AssignDiv<Integer> for IntMod

fn assign_div(&mut self, lhs: Integer, rhs: IntMod)

impl AssignDiv<Integer, &IntMod> for IntMod

fn assign_div(&mut self, lhs: Integer, rhs: &IntMod)

impl AssignDiv<Rational> for IntMod

fn assign_div(&mut self, lhs: Rational, rhs: IntMod)

impl AssignDiv<Rational, &IntMod> for IntMod

fn assign_div(&mut self, lhs: Rational, rhs: &IntMod)

impl AssignDiv<i16> for IntMod

fn assign_div(&mut self, lhs: i16, rhs: IntMod)

impl AssignDiv<i16, &IntMod> for IntMod

fn assign_div(&mut self, lhs: i16, rhs: &IntMod)

impl AssignDiv<i32> for IntMod

fn assign_div(&mut self, lhs: i32, rhs: IntMod)

impl AssignDiv<i32, &IntMod> for IntMod

fn assign_div(&mut self, lhs: i32, rhs: &IntMod)

impl AssignDiv<i64> for IntMod

fn assign_div(&mut self, lhs: i64, rhs: IntMod)

impl AssignDiv<i64, &IntMod> for IntMod

fn assign_div(&mut self, lhs: i64, rhs: &IntMod)

impl AssignDiv<i8> for IntMod

fn assign_div(&mut self, lhs: i8, rhs: IntMod)

impl AssignDiv<i8, &IntMod> for IntMod

fn assign_div(&mut self, lhs: i8, rhs: &IntMod)

impl AssignDiv<u16> for IntMod

fn assign_div(&mut self, lhs: u16, rhs: IntMod)

impl AssignDiv<u16, &IntMod> for IntMod

fn assign_div(&mut self, lhs: u16, rhs: &IntMod)

impl AssignDiv<u32> for IntMod

fn assign_div(&mut self, lhs: u32, rhs: IntMod)

impl AssignDiv<u32, &IntMod> for IntMod

fn assign_div(&mut self, lhs: u32, rhs: &IntMod)

impl AssignDiv<u64> for IntMod

fn assign_div(&mut self, lhs: u64, rhs: IntMod)

impl AssignDiv<u64, &IntMod> for IntMod

fn assign_div(&mut self, lhs: u64, rhs: &IntMod)

impl AssignDiv<u8> for IntMod

fn assign_div(&mut self, lhs: u8, rhs: IntMod)

impl AssignDiv<u8, &IntMod> for IntMod

fn assign_div(&mut self, lhs: u8, rhs: &IntMod)

impl AssignDiv for IntMod

fn assign_div(&mut self, lhs: IntMod, rhs: IntMod)

impl AssignMul<&IntMod> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: IntMod)

impl AssignMul<&IntMod, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: &IntMod)

impl AssignMul<&IntMod, &Integer> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: &Integer)

impl AssignMul<&IntMod, &Rational> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: &Rational)

impl AssignMul<&IntMod, &i16> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: &i16)

impl AssignMul<&IntMod, &i32> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: &i32)

impl AssignMul<&IntMod, &i64> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: &i64)

impl AssignMul<&IntMod, &i8> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: &i8)

impl AssignMul<&IntMod, &u16> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: &u16)

impl AssignMul<&IntMod, &u32> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: &u32)

impl AssignMul<&IntMod, &u64> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: &u64)

impl AssignMul<&IntMod, &u8> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: &u8)

impl AssignMul<&IntMod, Integer> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: Integer)

impl AssignMul<&IntMod, Rational> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: Rational)

impl AssignMul<&IntMod, i16> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: i16)

impl AssignMul<&IntMod, i32> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: i32)

impl AssignMul<&IntMod, i64> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: i64)

impl AssignMul<&IntMod, i8> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: i8)

impl AssignMul<&IntMod, u16> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: u16)

impl AssignMul<&IntMod, u32> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: u32)

impl AssignMul<&IntMod, u64> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: u64)

impl AssignMul<&IntMod, u8> for IntMod

fn assign_mul(&mut self, lhs: &IntMod, rhs: u8)

impl AssignMul<&Integer> for IntMod

fn assign_mul(&mut self, lhs: &Integer, rhs: IntMod)

impl AssignMul<&Integer, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: &Integer, rhs: &IntMod)

impl AssignMul<&Rational> for IntMod

fn assign_mul(&mut self, lhs: &Rational, rhs: IntMod)

impl AssignMul<&Rational, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: &Rational, rhs: &IntMod)

impl AssignMul<&i16> for IntMod

fn assign_mul(&mut self, lhs: &i16, rhs: IntMod)

impl AssignMul<&i16, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: &i16, rhs: &IntMod)

impl AssignMul<&i32> for IntMod

fn assign_mul(&mut self, lhs: &i32, rhs: IntMod)

impl AssignMul<&i32, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: &i32, rhs: &IntMod)

impl AssignMul<&i64> for IntMod

fn assign_mul(&mut self, lhs: &i64, rhs: IntMod)

impl AssignMul<&i64, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: &i64, rhs: &IntMod)

impl AssignMul<&i8> for IntMod

fn assign_mul(&mut self, lhs: &i8, rhs: IntMod)

impl AssignMul<&i8, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: &i8, rhs: &IntMod)

impl AssignMul<&u16> for IntMod

fn assign_mul(&mut self, lhs: &u16, rhs: IntMod)

impl AssignMul<&u16, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: &u16, rhs: &IntMod)

impl AssignMul<&u32> for IntMod

fn assign_mul(&mut self, lhs: &u32, rhs: IntMod)

impl AssignMul<&u32, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: &u32, rhs: &IntMod)

impl AssignMul<&u64> for IntMod

fn assign_mul(&mut self, lhs: &u64, rhs: IntMod)

impl AssignMul<&u64, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: &u64, rhs: &IntMod)

impl AssignMul<&u8> for IntMod

fn assign_mul(&mut self, lhs: &u8, rhs: IntMod)

impl AssignMul<&u8, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: &u8, rhs: &IntMod)

impl AssignMul<IntMod, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: &IntMod)

impl AssignMul<IntMod, &Integer> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: &Integer)

impl AssignMul<IntMod, &Rational> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: &Rational)

impl AssignMul<IntMod, &i16> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: &i16)

impl AssignMul<IntMod, &i32> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: &i32)

impl AssignMul<IntMod, &i64> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: &i64)

impl AssignMul<IntMod, &i8> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: &i8)

impl AssignMul<IntMod, &u16> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: &u16)

impl AssignMul<IntMod, &u32> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: &u32)

impl AssignMul<IntMod, &u64> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: &u64)

impl AssignMul<IntMod, &u8> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: &u8)

impl AssignMul<IntMod, Integer> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: Integer)

impl AssignMul<IntMod, Rational> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: Rational)

impl AssignMul<IntMod, i16> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: i16)

impl AssignMul<IntMod, i32> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: i32)

impl AssignMul<IntMod, i64> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: i64)

impl AssignMul<IntMod, i8> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: i8)

impl AssignMul<IntMod, u16> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: u16)

impl AssignMul<IntMod, u32> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: u32)

impl AssignMul<IntMod, u64> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: u64)

impl AssignMul<IntMod, u8> for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: u8)

impl AssignMul<Integer> for IntMod

fn assign_mul(&mut self, lhs: Integer, rhs: IntMod)

impl AssignMul<Integer, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: Integer, rhs: &IntMod)

impl AssignMul<Rational> for IntMod

fn assign_mul(&mut self, lhs: Rational, rhs: IntMod)

impl AssignMul<Rational, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: Rational, rhs: &IntMod)

impl AssignMul<i16> for IntMod

fn assign_mul(&mut self, lhs: i16, rhs: IntMod)

impl AssignMul<i16, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: i16, rhs: &IntMod)

impl AssignMul<i32> for IntMod

fn assign_mul(&mut self, lhs: i32, rhs: IntMod)

impl AssignMul<i32, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: i32, rhs: &IntMod)

impl AssignMul<i64> for IntMod

fn assign_mul(&mut self, lhs: i64, rhs: IntMod)

impl AssignMul<i64, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: i64, rhs: &IntMod)

impl AssignMul<i8> for IntMod

fn assign_mul(&mut self, lhs: i8, rhs: IntMod)

impl AssignMul<i8, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: i8, rhs: &IntMod)

impl AssignMul<u16> for IntMod

fn assign_mul(&mut self, lhs: u16, rhs: IntMod)

impl AssignMul<u16, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: u16, rhs: &IntMod)

impl AssignMul<u32> for IntMod

fn assign_mul(&mut self, lhs: u32, rhs: IntMod)

impl AssignMul<u32, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: u32, rhs: &IntMod)

impl AssignMul<u64> for IntMod

fn assign_mul(&mut self, lhs: u64, rhs: IntMod)

impl AssignMul<u64, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: u64, rhs: &IntMod)

impl AssignMul<u8> for IntMod

fn assign_mul(&mut self, lhs: u8, rhs: IntMod)

impl AssignMul<u8, &IntMod> for IntMod

fn assign_mul(&mut self, lhs: u8, rhs: &IntMod)

impl AssignMul for IntMod

fn assign_mul(&mut self, lhs: IntMod, rhs: IntMod)

impl AssignPow<&IntMod, &Integer> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: &Integer)

impl AssignPow<&IntMod, &i16> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: &i16)

impl AssignPow<&IntMod, &i32> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: &i32)

impl AssignPow<&IntMod, &i64> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: &i64)

impl AssignPow<&IntMod, &i8> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: &i8)

impl AssignPow<&IntMod, &u16> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: &u16)

impl AssignPow<&IntMod, &u32> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: &u32)

impl AssignPow<&IntMod, &u64> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: &u64)

impl AssignPow<&IntMod, &u8> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: &u8)

impl AssignPow<&IntMod, Integer> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: Integer)

impl AssignPow<&IntMod, i16> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: i16)

impl AssignPow<&IntMod, i32> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: i32)

impl AssignPow<&IntMod, i64> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: i64)

impl AssignPow<&IntMod, i8> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: i8)

impl AssignPow<&IntMod, u16> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: u16)

impl AssignPow<&IntMod, u32> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: u32)

impl AssignPow<&IntMod, u64> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: u64)

impl AssignPow<&IntMod, u8> for IntMod

fn assign_pow(&mut self, lhs: &IntMod, rhs: u8)

impl AssignPow<IntMod, &Integer> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: &Integer)

impl AssignPow<IntMod, &i16> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: &i16)

impl AssignPow<IntMod, &i32> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: &i32)

impl AssignPow<IntMod, &i64> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: &i64)

impl AssignPow<IntMod, &i8> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: &i8)

impl AssignPow<IntMod, &u16> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: &u16)

impl AssignPow<IntMod, &u32> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: &u32)

impl AssignPow<IntMod, &u64> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: &u64)

impl AssignPow<IntMod, &u8> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: &u8)

impl AssignPow<IntMod, Integer> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: Integer)

impl AssignPow<IntMod, i16> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: i16)

impl AssignPow<IntMod, i32> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: i32)

impl AssignPow<IntMod, i64> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: i64)

impl AssignPow<IntMod, i8> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: i8)

impl AssignPow<IntMod, u16> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: u16)

impl AssignPow<IntMod, u32> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: u32)

impl AssignPow<IntMod, u64> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: u64)

impl AssignPow<IntMod, u8> for IntMod

fn assign_pow(&mut self, lhs: IntMod, rhs: u8)

impl AssignSub<&IntMod> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: IntMod)

impl AssignSub<&IntMod, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: &IntMod)

impl AssignSub<&IntMod, &Integer> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: &Integer)

impl AssignSub<&IntMod, &Rational> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: &Rational)

impl AssignSub<&IntMod, &i16> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: &i16)

impl AssignSub<&IntMod, &i32> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: &i32)

impl AssignSub<&IntMod, &i64> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: &i64)

impl AssignSub<&IntMod, &i8> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: &i8)

impl AssignSub<&IntMod, &u16> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: &u16)

impl AssignSub<&IntMod, &u32> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: &u32)

impl AssignSub<&IntMod, &u64> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: &u64)

impl AssignSub<&IntMod, &u8> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: &u8)

impl AssignSub<&IntMod, Integer> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: Integer)

impl AssignSub<&IntMod, Rational> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: Rational)

impl AssignSub<&IntMod, i16> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: i16)

impl AssignSub<&IntMod, i32> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: i32)

impl AssignSub<&IntMod, i64> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: i64)

impl AssignSub<&IntMod, i8> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: i8)

impl AssignSub<&IntMod, u16> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: u16)

impl AssignSub<&IntMod, u32> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: u32)

impl AssignSub<&IntMod, u64> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: u64)

impl AssignSub<&IntMod, u8> for IntMod

fn assign_sub(&mut self, lhs: &IntMod, rhs: u8)

impl AssignSub<&Integer> for IntMod

fn assign_sub(&mut self, lhs: &Integer, rhs: IntMod)

impl AssignSub<&Integer, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: &Integer, rhs: &IntMod)

impl AssignSub<&Rational> for IntMod

fn assign_sub(&mut self, lhs: &Rational, rhs: IntMod)

impl AssignSub<&Rational, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: &Rational, rhs: &IntMod)

impl AssignSub<&i16> for IntMod

fn assign_sub(&mut self, lhs: &i16, rhs: IntMod)

impl AssignSub<&i16, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: &i16, rhs: &IntMod)

impl AssignSub<&i32> for IntMod

fn assign_sub(&mut self, lhs: &i32, rhs: IntMod)

impl AssignSub<&i32, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: &i32, rhs: &IntMod)

impl AssignSub<&i64> for IntMod

fn assign_sub(&mut self, lhs: &i64, rhs: IntMod)

impl AssignSub<&i64, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: &i64, rhs: &IntMod)

impl AssignSub<&i8> for IntMod

fn assign_sub(&mut self, lhs: &i8, rhs: IntMod)

impl AssignSub<&i8, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: &i8, rhs: &IntMod)

impl AssignSub<&u16> for IntMod

fn assign_sub(&mut self, lhs: &u16, rhs: IntMod)

impl AssignSub<&u16, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: &u16, rhs: &IntMod)

impl AssignSub<&u32> for IntMod

fn assign_sub(&mut self, lhs: &u32, rhs: IntMod)

impl AssignSub<&u32, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: &u32, rhs: &IntMod)

impl AssignSub<&u64> for IntMod

fn assign_sub(&mut self, lhs: &u64, rhs: IntMod)

impl AssignSub<&u64, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: &u64, rhs: &IntMod)

impl AssignSub<&u8> for IntMod

fn assign_sub(&mut self, lhs: &u8, rhs: IntMod)

impl AssignSub<&u8, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: &u8, rhs: &IntMod)

impl AssignSub<IntMod, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: &IntMod)

impl AssignSub<IntMod, &Integer> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: &Integer)

impl AssignSub<IntMod, &Rational> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: &Rational)

impl AssignSub<IntMod, &i16> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: &i16)

impl AssignSub<IntMod, &i32> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: &i32)

impl AssignSub<IntMod, &i64> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: &i64)

impl AssignSub<IntMod, &i8> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: &i8)

impl AssignSub<IntMod, &u16> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: &u16)

impl AssignSub<IntMod, &u32> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: &u32)

impl AssignSub<IntMod, &u64> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: &u64)

impl AssignSub<IntMod, &u8> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: &u8)

impl AssignSub<IntMod, Integer> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: Integer)

impl AssignSub<IntMod, Rational> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: Rational)

impl AssignSub<IntMod, i16> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: i16)

impl AssignSub<IntMod, i32> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: i32)

impl AssignSub<IntMod, i64> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: i64)

impl AssignSub<IntMod, i8> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: i8)

impl AssignSub<IntMod, u16> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: u16)

impl AssignSub<IntMod, u32> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: u32)

impl AssignSub<IntMod, u64> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: u64)

impl AssignSub<IntMod, u8> for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: u8)

impl AssignSub<Integer> for IntMod

fn assign_sub(&mut self, lhs: Integer, rhs: IntMod)

impl AssignSub<Integer, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: Integer, rhs: &IntMod)

impl AssignSub<Rational> for IntMod

fn assign_sub(&mut self, lhs: Rational, rhs: IntMod)

impl AssignSub<Rational, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: Rational, rhs: &IntMod)

impl AssignSub<i16> for IntMod

fn assign_sub(&mut self, lhs: i16, rhs: IntMod)

impl AssignSub<i16, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: i16, rhs: &IntMod)

impl AssignSub<i32> for IntMod

fn assign_sub(&mut self, lhs: i32, rhs: IntMod)

impl AssignSub<i32, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: i32, rhs: &IntMod)

impl AssignSub<i64> for IntMod

fn assign_sub(&mut self, lhs: i64, rhs: IntMod)

impl AssignSub<i64, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: i64, rhs: &IntMod)

impl AssignSub<i8> for IntMod

fn assign_sub(&mut self, lhs: i8, rhs: IntMod)

impl AssignSub<i8, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: i8, rhs: &IntMod)

impl AssignSub<u16> for IntMod

fn assign_sub(&mut self, lhs: u16, rhs: IntMod)

impl AssignSub<u16, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: u16, rhs: &IntMod)

impl AssignSub<u32> for IntMod

fn assign_sub(&mut self, lhs: u32, rhs: IntMod)

impl AssignSub<u32, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: u32, rhs: &IntMod)

impl AssignSub<u64> for IntMod

fn assign_sub(&mut self, lhs: u64, rhs: IntMod)

impl AssignSub<u64, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: u64, rhs: &IntMod)

impl AssignSub<u8> for IntMod

fn assign_sub(&mut self, lhs: u8, rhs: IntMod)

impl AssignSub<u8, &IntMod> for IntMod

fn assign_sub(&mut self, lhs: u8, rhs: &IntMod)

impl AssignSub for IntMod

fn assign_sub(&mut self, lhs: IntMod, rhs: IntMod)

impl Clone for IntMod

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IntMod

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

Formats the value using the given formatter.

impl Display for IntMod

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

Formats the value using the given formatter.

impl Div<&IntMod> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for &Integer

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for &Rational

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for &i16

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for &i32

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for &i64

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for &i8

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for &u16

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for &u32

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for &u64

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for &u8

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for Integer

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for Rational

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for i16

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for i32

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for i64

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for i8

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for u16

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for u32

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for u64

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&IntMod> for u8

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &IntMod) -> IntMod

Performs the / operation.

impl Div<&Integer> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> IntMod

Performs the / operation.

impl Div<&Integer> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> IntMod

Performs the / operation.

impl Div<&Rational> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> IntMod

Performs the / operation.

impl Div<&Rational> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> IntMod

Performs the / operation.

impl Div<&i16> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> IntMod

Performs the / operation.

impl Div<&i16> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> IntMod

Performs the / operation.

impl Div<&i32> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> IntMod

Performs the / operation.

impl Div<&i32> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> IntMod

Performs the / operation.

impl Div<&i64> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> IntMod

Performs the / operation.

impl Div<&i64> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> IntMod

Performs the / operation.

impl Div<&i8> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> IntMod

Performs the / operation.

impl Div<&i8> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> IntMod

Performs the / operation.

impl Div<&u16> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> IntMod

Performs the / operation.

impl Div<&u16> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> IntMod

Performs the / operation.

impl Div<&u32> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> IntMod

Performs the / operation.

impl Div<&u32> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> IntMod

Performs the / operation.

impl Div<&u64> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> IntMod

Performs the / operation.

impl Div<&u64> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> IntMod

Performs the / operation.

impl Div<&u8> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> IntMod

Performs the / operation.

impl Div<&u8> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> IntMod

Performs the / operation.

impl Div<IntMod> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for &Integer

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for &Rational

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for &i16

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for &i32

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for &i64

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for &i8

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for &u16

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for &u32

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for &u64

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for &u8

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for Integer

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for Rational

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for i16

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for i32

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for i64

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for i8

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for u16

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for u32

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for u64

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<IntMod> for u8

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl Div<Integer> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> IntMod

Performs the / operation.

impl Div<Integer> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> IntMod

Performs the / operation.

impl Div<Rational> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: Rational) -> IntMod

Performs the / operation.

impl Div<Rational> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: Rational) -> IntMod

Performs the / operation.

impl Div<i16> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> IntMod

Performs the / operation.

impl Div<i16> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> IntMod

Performs the / operation.

impl Div<i32> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> IntMod

Performs the / operation.

impl Div<i32> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> IntMod

Performs the / operation.

impl Div<i64> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> IntMod

Performs the / operation.

impl Div<i64> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> IntMod

Performs the / operation.

impl Div<i8> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> IntMod

Performs the / operation.

impl Div<i8> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> IntMod

Performs the / operation.

impl Div<u16> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> IntMod

Performs the / operation.

impl Div<u16> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> IntMod

Performs the / operation.

impl Div<u32> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> IntMod

Performs the / operation.

impl Div<u32> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> IntMod

Performs the / operation.

impl Div<u64> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> IntMod

Performs the / operation.

impl Div<u64> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> IntMod

Performs the / operation.

impl Div<u8> for &IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> IntMod

Performs the / operation.

impl Div<u8> for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> IntMod

Performs the / operation.

impl Div for IntMod

type Output = IntMod

The resulting type after applying the / operator.

fn div(self, rhs: IntMod) -> IntMod

Performs the / operation.

impl DivAssign<&IntMod> for IntMod

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

Performs the /= operation.

impl DivAssign<&Integer> for IntMod

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

Performs the /= operation.

impl DivAssign<&Rational> for IntMod

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

Performs the /= operation.

impl DivAssign<&i16> for IntMod

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

Performs the /= operation.

impl DivAssign<&i32> for IntMod

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

Performs the /= operation.

impl DivAssign<&i64> for IntMod

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

Performs the /= operation.

impl DivAssign<&i8> for IntMod

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

Performs the /= operation.

impl DivAssign<&u16> for IntMod

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

Performs the /= operation.

impl DivAssign<&u32> for IntMod

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

Performs the /= operation.

impl DivAssign<&u64> for IntMod

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

Performs the /= operation.

impl DivAssign<&u8> for IntMod

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

Performs the /= operation.

impl DivAssign<Integer> for IntMod

fn div_assign(&mut self, rhs: Integer)

Performs the /= operation.

impl DivAssign<Rational> for IntMod

fn div_assign(&mut self, rhs: Rational)

Performs the /= operation.

impl DivAssign<i16> for IntMod

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl DivAssign<i32> for IntMod

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl DivAssign<i64> for IntMod

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl DivAssign<i8> for IntMod

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl DivAssign<u16> for IntMod

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl DivAssign<u32> for IntMod

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl DivAssign<u64> for IntMod

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl DivAssign<u8> for IntMod

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl DivAssign for IntMod

fn div_assign(&mut self, rhs: IntMod)

Performs the /= operation.

impl DivFrom<&IntMod> for IntMod

fn div_from(&mut self, lhs: &IntMod)

impl DivFrom<&Integer> for IntMod

fn div_from(&mut self, lhs: &Integer)

impl DivFrom<&Rational> for IntMod

fn div_from(&mut self, lhs: &Rational)

impl DivFrom<&i16> for IntMod

fn div_from(&mut self, lhs: &i16)

impl DivFrom<&i32> for IntMod

fn div_from(&mut self, lhs: &i32)

impl DivFrom<&i64> for IntMod

fn div_from(&mut self, lhs: &i64)

impl DivFrom<&i8> for IntMod

fn div_from(&mut self, lhs: &i8)

impl DivFrom<&u16> for IntMod

fn div_from(&mut self, lhs: &u16)

impl DivFrom<&u32> for IntMod

fn div_from(&mut self, lhs: &u32)

impl DivFrom<&u64> for IntMod

fn div_from(&mut self, lhs: &u64)

impl DivFrom<&u8> for IntMod

fn div_from(&mut self, lhs: &u8)

impl DivFrom<Integer> for IntMod

fn div_from(&mut self, lhs: Integer)

impl DivFrom<Rational> for IntMod

fn div_from(&mut self, lhs: Rational)

impl DivFrom<i16> for IntMod

fn div_from(&mut self, lhs: i16)

impl DivFrom<i32> for IntMod

fn div_from(&mut self, lhs: i32)

impl DivFrom<i64> for IntMod

fn div_from(&mut self, lhs: i64)

impl DivFrom<i8> for IntMod

fn div_from(&mut self, lhs: i8)

impl DivFrom<u16> for IntMod

fn div_from(&mut self, lhs: u16)

impl DivFrom<u32> for IntMod

fn div_from(&mut self, lhs: u32)

impl DivFrom<u64> for IntMod

fn div_from(&mut self, lhs: u64)

impl DivFrom<u8> for IntMod

fn div_from(&mut self, lhs: u8)

impl DivFrom for IntMod

fn div_from(&mut self, lhs: IntMod)

impl Drop for IntMod

fn drop(&mut self)

Executes the destructor for this type.

impl From<&IntMod> for IntModPoly

fn from(src: &IntMod) -> IntModPoly

Converts to this type from the input type.

impl From<&IntMod> for IntPoly

fn from(src: &IntMod) -> IntPoly

Converts to this type from the input type.

impl From<&IntMod> for Integer

fn from(src: &IntMod) -> Integer

Converts to this type from the input type.

impl From<&IntMod> for RatFunc

fn from(x: &IntMod) -> RatFunc

Converts to this type from the input type.

impl From<&IntMod> for RatPoly

fn from(src: &IntMod) -> RatPoly

Converts to this type from the input type.

impl From<&IntMod> for Rational

fn from(src: &IntMod) -> Rational

Converts to this type from the input type.

impl From<IntMod> for IntModPoly

fn from(src: IntMod) -> IntModPoly

Converts to this type from the input type.

impl From<IntMod> for IntPoly

fn from(src: IntMod) -> IntPoly

Converts to this type from the input type.

impl From<IntMod> for Integer

fn from(src: IntMod) -> Integer

Converts to this type from the input type.

impl From<IntMod> for RatFunc

fn from(src: IntMod) -> RatFunc

Converts to this type from the input type.

impl From<IntMod> for RatPoly

fn from(src: IntMod) -> RatPoly

Converts to this type from the input type.

impl From<IntMod> for Rational

fn from(src: IntMod) -> Rational

Converts to this type from the input type.

impl Hash for IntMod

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Inv for &IntMod

type Output = IntMod

fn inv(self) -> IntMod

impl Inv for IntMod

type Output = IntMod

fn inv(self) -> IntMod

impl InvAssign for IntMod

fn inv_assign(&mut self)

impl Mul<&IntMod> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for &Integer

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for &Rational

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for &i16

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for &i32

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for &i64

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for &i8

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for &u16

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for &u32

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for &u64

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for &u8

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for Integer

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for Rational

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for i16

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for i32

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for i64

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for i8

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for u16

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for u32

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for u64

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&IntMod> for u8

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &IntMod) -> IntMod

Performs the * operation.

impl Mul<&Integer> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> IntMod

Performs the * operation.

impl Mul<&Integer> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> IntMod

Performs the * operation.

impl Mul<&Rational> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> IntMod

Performs the * operation.

impl Mul<&Rational> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &Rational) -> IntMod

Performs the * operation.

impl Mul<&i16> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> IntMod

Performs the * operation.

impl Mul<&i16> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> IntMod

Performs the * operation.

impl Mul<&i32> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> IntMod

Performs the * operation.

impl Mul<&i32> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> IntMod

Performs the * operation.

impl Mul<&i64> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> IntMod

Performs the * operation.

impl Mul<&i64> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> IntMod

Performs the * operation.

impl Mul<&i8> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> IntMod

Performs the * operation.

impl Mul<&i8> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> IntMod

Performs the * operation.

impl Mul<&u16> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> IntMod

Performs the * operation.

impl Mul<&u16> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> IntMod

Performs the * operation.

impl Mul<&u32> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> IntMod

Performs the * operation.

impl Mul<&u32> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> IntMod

Performs the * operation.

impl Mul<&u64> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> IntMod

Performs the * operation.

impl Mul<&u64> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> IntMod

Performs the * operation.

impl Mul<&u8> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> IntMod

Performs the * operation.

impl Mul<&u8> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> IntMod

Performs the * operation.

impl Mul<IntMod> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for &Integer

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for &Rational

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for &i16

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for &i32

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for &i64

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for &i8

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for &u16

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for &u32

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for &u64

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for &u8

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for Integer

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for Rational

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for i16

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for i32

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for i64

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for i8

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for u16

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for u32

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for u64

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<IntMod> for u8

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl Mul<Integer> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> IntMod

Performs the * operation.

impl Mul<Integer> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> IntMod

Performs the * operation.

impl Mul<Rational> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: Rational) -> IntMod

Performs the * operation.

impl Mul<Rational> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: Rational) -> IntMod

Performs the * operation.

impl Mul<i16> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> IntMod

Performs the * operation.

impl Mul<i16> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> IntMod

Performs the * operation.

impl Mul<i32> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> IntMod

Performs the * operation.

impl Mul<i32> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> IntMod

Performs the * operation.

impl Mul<i64> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> IntMod

Performs the * operation.

impl Mul<i64> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> IntMod

Performs the * operation.

impl Mul<i8> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> IntMod

Performs the * operation.

impl Mul<i8> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> IntMod

Performs the * operation.

impl Mul<u16> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> IntMod

Performs the * operation.

impl Mul<u16> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> IntMod

Performs the * operation.

impl Mul<u32> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> IntMod

Performs the * operation.

impl Mul<u32> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> IntMod

Performs the * operation.

impl Mul<u64> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> IntMod

Performs the * operation.

impl Mul<u64> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> IntMod

Performs the * operation.

impl Mul<u8> for &IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> IntMod

Performs the * operation.

impl Mul<u8> for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> IntMod

Performs the * operation.

impl Mul for IntMod

type Output = IntMod

The resulting type after applying the * operator.

fn mul(self, rhs: IntMod) -> IntMod

Performs the * operation.

impl MulAssign<&IntMod> for IntMod

fn mul_assign(&mut self, rhs: &IntMod)

Performs the *= operation.

impl MulAssign<&Integer> for IntMod

fn mul_assign(&mut self, rhs: &Integer)

Performs the *= operation.

impl MulAssign<&Rational> for IntMod

fn mul_assign(&mut self, rhs: &Rational)

Performs the *= operation.

impl MulAssign<&i16> for IntMod

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

Performs the *= operation.

impl MulAssign<&i32> for IntMod

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

Performs the *= operation.

impl MulAssign<&i64> for IntMod

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

Performs the *= operation.

impl MulAssign<&i8> for IntMod

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

Performs the *= operation.

impl MulAssign<&u16> for IntMod

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

Performs the *= operation.

impl MulAssign<&u32> for IntMod

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

Performs the *= operation.

impl MulAssign<&u64> for IntMod

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

Performs the *= operation.

impl MulAssign<&u8> for IntMod

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

Performs the *= operation.

impl MulAssign<Integer> for IntMod

fn mul_assign(&mut self, rhs: Integer)

Performs the *= operation.

impl MulAssign<Rational> for IntMod

fn mul_assign(&mut self, rhs: Rational)

Performs the *= operation.

impl MulAssign<i16> for IntMod

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl MulAssign<i32> for IntMod

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl MulAssign<i64> for IntMod

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl MulAssign<i8> for IntMod

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl MulAssign<u16> for IntMod

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl MulAssign<u32> for IntMod

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl MulAssign<u64> for IntMod

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl MulAssign<u8> for IntMod

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl MulAssign for IntMod

fn mul_assign(&mut self, rhs: IntMod)

Performs the *= operation.

impl MulFrom<&IntMod> for IntMod

fn mul_from(&mut self, lhs: &IntMod)

impl MulFrom<&Integer> for IntMod

fn mul_from(&mut self, lhs: &Integer)

impl MulFrom<&Rational> for IntMod

fn mul_from(&mut self, lhs: &Rational)

impl MulFrom<&i16> for IntMod

fn mul_from(&mut self, lhs: &i16)

impl MulFrom<&i32> for IntMod

fn mul_from(&mut self, lhs: &i32)

impl MulFrom<&i64> for IntMod

fn mul_from(&mut self, lhs: &i64)

impl MulFrom<&i8> for IntMod

fn mul_from(&mut self, lhs: &i8)

impl MulFrom<&u16> for IntMod

fn mul_from(&mut self, lhs: &u16)

impl MulFrom<&u32> for IntMod

fn mul_from(&mut self, lhs: &u32)

impl MulFrom<&u64> for IntMod

fn mul_from(&mut self, lhs: &u64)

impl MulFrom<&u8> for IntMod

fn mul_from(&mut self, lhs: &u8)

impl MulFrom<Integer> for IntMod

fn mul_from(&mut self, lhs: Integer)

impl MulFrom<Rational> for IntMod

fn mul_from(&mut self, lhs: Rational)

impl MulFrom<i16> for IntMod

fn mul_from(&mut self, lhs: i16)

impl MulFrom<i32> for IntMod

fn mul_from(&mut self, lhs: i32)

impl MulFrom<i64> for IntMod

fn mul_from(&mut self, lhs: i64)

impl MulFrom<i8> for IntMod

fn mul_from(&mut self, lhs: i8)

impl MulFrom<u16> for IntMod

fn mul_from(&mut self, lhs: u16)

impl MulFrom<u32> for IntMod

fn mul_from(&mut self, lhs: u32)

impl MulFrom<u64> for IntMod

fn mul_from(&mut self, lhs: u64)

impl MulFrom<u8> for IntMod

fn mul_from(&mut self, lhs: u8)

impl MulFrom for IntMod

fn mul_from(&mut self, lhs: IntMod)

impl Neg for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn neg(self) -> IntMod

Performs the unary - operation.

impl Neg for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn neg(self) -> IntMod

Performs the unary - operation.

impl NegAssign for IntMod

fn neg_assign(&mut self)

impl<T: Into<Integer>> NewCtx<T, IntModCtx> for IntMod

fn new(src: T, ctx: &IntModCtx) -> Self

impl PartialEq<&IntMod> for IntMod

fn eq(&self, rhs: &&IntMod) -> 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 PartialEq<&IntMod> for IntModPoly

fn eq(&self, rhs: &&IntMod) -> 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 PartialEq<&IntMod> for Integer

fn eq(&self, rhs: &&IntMod) -> 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 PartialEq<&IntMod> for Rational

fn eq(&self, rhs: &&IntMod) -> 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 PartialEq<&IntMod> for i16

fn eq(&self, rhs: &&IntMod) -> 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 PartialEq<&IntMod> for i32

fn eq(&self, rhs: &&IntMod) -> 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 PartialEq<&IntMod> for i64

fn eq(&self, rhs: &&IntMod) -> 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 PartialEq<&IntMod> for i8

fn eq(&self, rhs: &&IntMod) -> 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 PartialEq<&IntMod> for u16

fn eq(&self, rhs: &&IntMod) -> 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 PartialEq<&IntMod> for u32

fn eq(&self, rhs: &&IntMod) -> 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 PartialEq<&IntMod> for u64

fn eq(&self, rhs: &&IntMod) -> 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 PartialEq<&IntMod> for u8

fn eq(&self, rhs: &&IntMod) -> 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 PartialEq<&Integer> for IntMod

fn eq(&self, rhs: &&Integer) -> 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 PartialEq<&Rational> for IntMod

fn eq(&self, rhs: &&Rational) -> 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 PartialEq<&i16> for IntMod

fn eq(&self, rhs: &&i16) -> 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 PartialEq<&i32> for IntMod

fn eq(&self, rhs: &&i32) -> 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 PartialEq<&i64> for IntMod

fn eq(&self, rhs: &&i64) -> 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 PartialEq<&i8> for IntMod

fn eq(&self, rhs: &&i8) -> 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 PartialEq<&u16> for IntMod

fn eq(&self, rhs: &&u16) -> 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 PartialEq<&u32> for IntMod

fn eq(&self, rhs: &&u32) -> 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 PartialEq<&u64> for IntMod

fn eq(&self, rhs: &&u64) -> 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 PartialEq<&u8> for IntMod

fn eq(&self, rhs: &&u8) -> 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 PartialEq<IntMod> for &IntMod

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for &IntModPoly

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for &Integer

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for &Rational

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for &i16

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for &i32

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for &i64

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for &i8

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for &u16

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for &u32

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for &u64

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for &u8

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for IntModPoly

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for Integer

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for Rational

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for i16

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for i32

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for i64

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for i8

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for u16

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for u32

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for u64

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<IntMod> for u8

fn eq(&self, rhs: &IntMod) -> 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 PartialEq<Integer> for &IntMod

fn eq(&self, rhs: &Integer) -> 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 PartialEq<Integer> for IntMod

fn eq(&self, rhs: &Integer) -> 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 PartialEq<Rational> for &IntMod

fn eq(&self, rhs: &Rational) -> 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 PartialEq<Rational> for IntMod

fn eq(&self, rhs: &Rational) -> 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 PartialEq<i16> for &IntMod

fn eq(&self, rhs: &i16) -> 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 PartialEq<i16> for IntMod

fn eq(&self, rhs: &i16) -> 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 PartialEq<i32> for &IntMod

fn eq(&self, rhs: &i32) -> 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 PartialEq<i32> for IntMod

fn eq(&self, rhs: &i32) -> 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 PartialEq<i64> for &IntMod

fn eq(&self, rhs: &i64) -> 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 PartialEq<i64> for IntMod

fn eq(&self, rhs: &i64) -> 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 PartialEq<i8> for &IntMod

fn eq(&self, rhs: &i8) -> 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 PartialEq<i8> for IntMod

fn eq(&self, rhs: &i8) -> 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 PartialEq<u16> for &IntMod

fn eq(&self, rhs: &u16) -> 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 PartialEq<u16> for IntMod

fn eq(&self, rhs: &u16) -> 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 PartialEq<u32> for &IntMod

fn eq(&self, rhs: &u32) -> 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 PartialEq<u32> for IntMod

fn eq(&self, rhs: &u32) -> 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 PartialEq<u64> for &IntMod

fn eq(&self, rhs: &u64) -> 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 PartialEq<u64> for IntMod

fn eq(&self, rhs: &u64) -> 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 PartialEq<u8> for &IntMod

fn eq(&self, rhs: &u8) -> 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 PartialEq<u8> for IntMod

fn eq(&self, rhs: &u8) -> 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 PartialEq for IntMod

fn eq(&self, rhs: &IntMod) -> 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 Pow<&Integer> for &IntMod

type Output = IntMod

fn pow(self, rhs: &Integer) -> IntMod

impl Pow<&Integer> for IntMod

type Output = IntMod

fn pow(self, rhs: &Integer) -> IntMod

impl Pow<&i16> for &IntMod

type Output = IntMod

fn pow(self, rhs: &i16) -> IntMod

impl Pow<&i16> for IntMod

type Output = IntMod

fn pow(self, rhs: &i16) -> IntMod

impl Pow<&i32> for &IntMod

type Output = IntMod

fn pow(self, rhs: &i32) -> IntMod

impl Pow<&i32> for IntMod

type Output = IntMod

fn pow(self, rhs: &i32) -> IntMod

impl Pow<&i64> for &IntMod

type Output = IntMod

fn pow(self, rhs: &i64) -> IntMod

impl Pow<&i64> for IntMod

type Output = IntMod

fn pow(self, rhs: &i64) -> IntMod

impl Pow<&i8> for &IntMod

type Output = IntMod

fn pow(self, rhs: &i8) -> IntMod

impl Pow<&i8> for IntMod

type Output = IntMod

fn pow(self, rhs: &i8) -> IntMod

impl Pow<&u16> for &IntMod

type Output = IntMod

fn pow(self, rhs: &u16) -> IntMod

impl Pow<&u16> for IntMod

type Output = IntMod

fn pow(self, rhs: &u16) -> IntMod

impl Pow<&u32> for &IntMod

type Output = IntMod

fn pow(self, rhs: &u32) -> IntMod

impl Pow<&u32> for IntMod

type Output = IntMod

fn pow(self, rhs: &u32) -> IntMod

impl Pow<&u64> for &IntMod

type Output = IntMod

fn pow(self, rhs: &u64) -> IntMod

impl Pow<&u64> for IntMod

type Output = IntMod

fn pow(self, rhs: &u64) -> IntMod

impl Pow<&u8> for &IntMod

type Output = IntMod

fn pow(self, rhs: &u8) -> IntMod

impl Pow<&u8> for IntMod

type Output = IntMod

fn pow(self, rhs: &u8) -> IntMod

impl Pow<Integer> for &IntMod

type Output = IntMod

fn pow(self, rhs: Integer) -> IntMod

impl Pow<Integer> for IntMod

type Output = IntMod

fn pow(self, rhs: Integer) -> IntMod

impl Pow<i16> for &IntMod

type Output = IntMod

fn pow(self, rhs: i16) -> IntMod

impl Pow<i16> for IntMod

type Output = IntMod

fn pow(self, rhs: i16) -> IntMod

impl Pow<i32> for &IntMod

type Output = IntMod

fn pow(self, rhs: i32) -> IntMod

impl Pow<i32> for IntMod

type Output = IntMod

fn pow(self, rhs: i32) -> IntMod

impl Pow<i64> for &IntMod

type Output = IntMod

fn pow(self, rhs: i64) -> IntMod

impl Pow<i64> for IntMod

type Output = IntMod

fn pow(self, rhs: i64) -> IntMod

impl Pow<i8> for &IntMod

type Output = IntMod

fn pow(self, rhs: i8) -> IntMod

impl Pow<i8> for IntMod

type Output = IntMod

fn pow(self, rhs: i8) -> IntMod

impl Pow<u16> for &IntMod

type Output = IntMod

fn pow(self, rhs: u16) -> IntMod

impl Pow<u16> for IntMod

type Output = IntMod

fn pow(self, rhs: u16) -> IntMod

impl Pow<u32> for &IntMod

type Output = IntMod

fn pow(self, rhs: u32) -> IntMod

impl Pow<u32> for IntMod

type Output = IntMod

fn pow(self, rhs: u32) -> IntMod

impl Pow<u64> for &IntMod

type Output = IntMod

fn pow(self, rhs: u64) -> IntMod

impl Pow<u64> for IntMod

type Output = IntMod

fn pow(self, rhs: u64) -> IntMod

impl Pow<u8> for &IntMod

type Output = IntMod

fn pow(self, rhs: u8) -> IntMod

impl Pow<u8> for IntMod

type Output = IntMod

fn pow(self, rhs: u8) -> IntMod

impl PowAssign<&Integer> for IntMod

fn pow_assign(&mut self, rhs: &Integer)

impl PowAssign<&i16> for IntMod

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

impl PowAssign<&i32> for IntMod

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

impl PowAssign<&i64> for IntMod

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

impl PowAssign<&i8> for IntMod

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

impl PowAssign<&u16> for IntMod

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

impl PowAssign<&u32> for IntMod

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

impl PowAssign<&u64> for IntMod

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

impl PowAssign<&u8> for IntMod

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

impl PowAssign<Integer> for IntMod

fn pow_assign(&mut self, rhs: Integer)

impl PowAssign<i16> for IntMod

fn pow_assign(&mut self, rhs: i16)

impl PowAssign<i32> for IntMod

fn pow_assign(&mut self, rhs: i32)

impl PowAssign<i64> for IntMod

fn pow_assign(&mut self, rhs: i64)

impl PowAssign<i8> for IntMod

fn pow_assign(&mut self, rhs: i8)

impl PowAssign<u16> for IntMod

fn pow_assign(&mut self, rhs: u16)

impl PowAssign<u32> for IntMod

fn pow_assign(&mut self, rhs: u32)

impl PowAssign<u64> for IntMod

fn pow_assign(&mut self, rhs: u64)

impl PowAssign<u8> for IntMod

fn pow_assign(&mut self, rhs: u8)

impl Sub<&IntMod> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for &Integer

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for &Rational

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for &i16

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for &i32

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for &i64

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for &i8

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for &u16

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for &u32

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for &u64

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for &u8

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for Integer

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for Rational

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for i16

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for i32

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for i64

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for i8

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for u16

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for u32

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for u64

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&IntMod> for u8

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &IntMod) -> IntMod

Performs the - operation.

impl Sub<&Integer> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> IntMod

Performs the - operation.

impl Sub<&Integer> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> IntMod

Performs the - operation.

impl Sub<&Rational> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> IntMod

Performs the - operation.

impl Sub<&Rational> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> IntMod

Performs the - operation.

impl Sub<&i16> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> IntMod

Performs the - operation.

impl Sub<&i16> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> IntMod

Performs the - operation.

impl Sub<&i32> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> IntMod

Performs the - operation.

impl Sub<&i32> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> IntMod

Performs the - operation.

impl Sub<&i64> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> IntMod

Performs the - operation.

impl Sub<&i64> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> IntMod

Performs the - operation.

impl Sub<&i8> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> IntMod

Performs the - operation.

impl Sub<&i8> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> IntMod

Performs the - operation.

impl Sub<&u16> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> IntMod

Performs the - operation.

impl Sub<&u16> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> IntMod

Performs the - operation.

impl Sub<&u32> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> IntMod

Performs the - operation.

impl Sub<&u32> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> IntMod

Performs the - operation.

impl Sub<&u64> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> IntMod

Performs the - operation.

impl Sub<&u64> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> IntMod

Performs the - operation.

impl Sub<&u8> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> IntMod

Performs the - operation.

impl Sub<&u8> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> IntMod

Performs the - operation.

impl Sub<IntMod> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for &Integer

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for &Rational

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for &i16

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for &i32

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for &i64

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for &i8

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for &u16

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for &u32

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for &u64

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for &u8

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for Integer

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for Rational

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for i16

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for i32

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for i64

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for i8

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for u16

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for u32

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for u64

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<IntMod> for u8

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl Sub<Integer> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> IntMod

Performs the - operation.

impl Sub<Integer> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> IntMod

Performs the - operation.

impl Sub<Rational> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: Rational) -> IntMod

Performs the - operation.

impl Sub<Rational> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: Rational) -> IntMod

Performs the - operation.

impl Sub<i16> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> IntMod

Performs the - operation.

impl Sub<i16> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> IntMod

Performs the - operation.

impl Sub<i32> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> IntMod

Performs the - operation.

impl Sub<i32> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> IntMod

Performs the - operation.

impl Sub<i64> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> IntMod

Performs the - operation.

impl Sub<i64> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> IntMod

Performs the - operation.

impl Sub<i8> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> IntMod

Performs the - operation.

impl Sub<i8> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> IntMod

Performs the - operation.

impl Sub<u16> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> IntMod

Performs the - operation.

impl Sub<u16> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> IntMod

Performs the - operation.

impl Sub<u32> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> IntMod

Performs the - operation.

impl Sub<u32> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> IntMod

Performs the - operation.

impl Sub<u64> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> IntMod

Performs the - operation.

impl Sub<u64> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> IntMod

Performs the - operation.

impl Sub<u8> for &IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> IntMod

Performs the - operation.

impl Sub<u8> for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> IntMod

Performs the - operation.

impl Sub for IntMod

type Output = IntMod

The resulting type after applying the - operator.

fn sub(self, rhs: IntMod) -> IntMod

Performs the - operation.

impl SubAssign<&IntMod> for IntMod

fn sub_assign(&mut self, rhs: &IntMod)

Performs the -= operation.

impl SubAssign<&Integer> for IntMod

fn sub_assign(&mut self, rhs: &Integer)

Performs the -= operation.

impl SubAssign<&Rational> for IntMod

fn sub_assign(&mut self, rhs: &Rational)

Performs the -= operation.

impl SubAssign<&i16> for IntMod

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

Performs the -= operation.

impl SubAssign<&i32> for IntMod

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

Performs the -= operation.

impl SubAssign<&i64> for IntMod

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

Performs the -= operation.

impl SubAssign<&i8> for IntMod

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

Performs the -= operation.

impl SubAssign<&u16> for IntMod

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

Performs the -= operation.

impl SubAssign<&u32> for IntMod

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

Performs the -= operation.

impl SubAssign<&u64> for IntMod

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

Performs the -= operation.

impl SubAssign<&u8> for IntMod

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

Performs the -= operation.

impl SubAssign<Integer> for IntMod

fn sub_assign(&mut self, rhs: Integer)

Performs the -= operation.

impl SubAssign<Rational> for IntMod

fn sub_assign(&mut self, rhs: Rational)

Performs the -= operation.

impl SubAssign<i16> for IntMod

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl SubAssign<i32> for IntMod

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl SubAssign<i64> for IntMod

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl SubAssign<i8> for IntMod

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl SubAssign<u16> for IntMod

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl SubAssign<u32> for IntMod

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl SubAssign<u64> for IntMod

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl SubAssign<u8> for IntMod

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl SubAssign for IntMod

fn sub_assign(&mut self, rhs: IntMod)

Performs the -= operation.

impl SubFrom<&IntMod> for IntMod

fn sub_from(&mut self, lhs: &IntMod)

impl SubFrom<&Integer> for IntMod

fn sub_from(&mut self, lhs: &Integer)

impl SubFrom<&Rational> for IntMod

fn sub_from(&mut self, lhs: &Rational)

impl SubFrom<&i16> for IntMod

fn sub_from(&mut self, lhs: &i16)

impl SubFrom<&i32> for IntMod

fn sub_from(&mut self, lhs: &i32)

impl SubFrom<&i64> for IntMod

fn sub_from(&mut self, lhs: &i64)

impl SubFrom<&i8> for IntMod

fn sub_from(&mut self, lhs: &i8)

impl SubFrom<&u16> for IntMod

fn sub_from(&mut self, lhs: &u16)

impl SubFrom<&u32> for IntMod

fn sub_from(&mut self, lhs: &u32)

impl SubFrom<&u64> for IntMod

fn sub_from(&mut self, lhs: &u64)

impl SubFrom<&u8> for IntMod

fn sub_from(&mut self, lhs: &u8)

impl SubFrom<Integer> for IntMod

fn sub_from(&mut self, lhs: Integer)

impl SubFrom<Rational> for IntMod

fn sub_from(&mut self, lhs: Rational)

impl SubFrom<i16> for IntMod

fn sub_from(&mut self, lhs: i16)

impl SubFrom<i32> for IntMod

fn sub_from(&mut self, lhs: i32)

impl SubFrom<i64> for IntMod

fn sub_from(&mut self, lhs: i64)

impl SubFrom<i8> for IntMod

fn sub_from(&mut self, lhs: i8)

impl SubFrom<u16> for IntMod

fn sub_from(&mut self, lhs: u16)

impl SubFrom<u32> for IntMod

fn sub_from(&mut self, lhs: u32)

impl SubFrom<u64> for IntMod

fn sub_from(&mut self, lhs: u64)

impl SubFrom<u8> for IntMod

fn sub_from(&mut self, lhs: u8)

impl SubFrom for IntMod

fn sub_from(&mut self, lhs: IntMod)

impl Eq for IntMod