Type Alias Big 

pub type Big<const S: usize> = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>;

An arbitrary precision rational, with S words of its numerator and denominator held inline.

The capacity is part of the type, so a crate implementing Absorb for its own narrow value against this one names the capacity it implements it for.

Aliased Type

pub struct Big<const S: usize> { /* private fields */ }

Implementations

impl<const S: usize> Big<S>

pub fn new(numerator: i64, denominator: u64) -> Option<Self>

impl<const S: usize> Big<S>

pub fn new_signed<T: Into<Sign>>( sign: T, numerator: u64, denominator: u64, ) -> Option<Self>

Trait Implementations

impl<const S: usize, N> Absorb<&N> for Big<S>

where Big<S>: Absorb<N>,

A matrix provider that hands out references to what it stores is read through them.

fn from_narrow(narrow: &&N) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &&N)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &&N)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &&N) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &&N, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<Binary> for Big<S>

fn from_narrow(narrow: &Binary) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &Binary)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &Binary)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &Binary) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &Binary, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<One> for Big<S>

fn from_narrow(_: &One) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, _: &One)

Add a narrow value to this one.

fn sub_narrow(&mut self, _: &One)

Subtract a narrow value from this one.

fn mul_narrow(&self, _: &One) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, _: &One, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize, N> Absorb<Option<N>> for Big<S>

where Big<S>: Absorb<N>,

An absent value is zero, so it contributes nothing.

Sparse rows are stored as Options to keep the zeros out. This lift is written for the wide type rather than once for every wide type at once, because Self has to be local to the crate that writes the implementation; a crate defining its own accumulator writes its own.

fn from_narrow(narrow: &Option<N>) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &Option<N>)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &Option<N>)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &Option<N>) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &Option<N>, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<SignedOne> for Big<S>

fn from_narrow(narrow: &SignedOne) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &SignedOne)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &SignedOne)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &SignedOne) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &SignedOne, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<Zero> for Big<S>

fn from_narrow(_: &Zero) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, _: &Zero)

Add a narrow value to this one.

fn sub_narrow(&mut self, _: &Zero)

Subtract a narrow value from this one.

fn mul_narrow(&self, _: &Zero) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, _: &Zero, _: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<i8> for Big<S>

fn from_narrow(narrow: &i8) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &i8)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &i8)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &i8) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &i8, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<i16> for Big<S>

fn from_narrow(narrow: &i16) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &i16)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &i16)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &i16) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &i16, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<i32> for Big<S>

fn from_narrow(narrow: &i32) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &i32)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &i32)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &i32) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &i32, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<i64> for Big<S>

fn from_narrow(narrow: &i64) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &i64)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &i64)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &i64) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &i64, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<isize> for Big<S>

fn from_narrow(narrow: &isize) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &isize)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &isize)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &isize) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &isize, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<u8> for Big<S>

fn from_narrow(narrow: &u8) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &u8)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &u8)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &u8) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &u8, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<u16> for Big<S>

fn from_narrow(narrow: &u16) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &u16)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &u16)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &u16) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &u16, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<u32> for Big<S>

fn from_narrow(narrow: &u32) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &u32)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &u32)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &u32) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &u32, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<u64> for Big<S>

fn from_narrow(narrow: &u64) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &u64)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &u64)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &u64) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &u64, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Absorb<usize> for Big<S>

fn from_narrow(narrow: &usize) -> Self

The narrow value in the wide type.

fn add_narrow(&mut self, narrow: &usize)

Add a narrow value to this one.

fn sub_narrow(&mut self, narrow: &usize)

Subtract a narrow value from this one.

fn mul_narrow(&self, narrow: &usize) -> Self

Multiply this value by a narrow one.

fn add_mul_narrow(&mut self, narrow: &usize, other: &Self)

Add the product of a narrow value and a wide one to this value.

impl<const S: usize> Add for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: Big<S>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&Binary> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &Binary) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<i8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroI8) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<i8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroI8) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<i16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroI16) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<i16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroI16) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<i32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroI32) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<i32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroI32) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<i64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroI64) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<i64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroI64) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<isize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroIsize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<isize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroIsize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<u8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroU8) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<u8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroU8) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<u16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroU16) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<u16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroU16) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<u32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroU32) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<u32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroU32) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<u64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroU64) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<u64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroU64) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<usize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroUsize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZero<usize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroUsize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&NonZeroUbig<S>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZeroUbig<S>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&One> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, _: &One) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&Ubig<S>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &Ubig<S>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&Zero> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, _: &Zero) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&i8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&i8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&i16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&i16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&i32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&i32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&i64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&i64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&isize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&isize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&u8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&u8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&u16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&u16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&u32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&u32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&u64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&u64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const S: usize> Add<&usize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<&usize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<Binary> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: Binary) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<i8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroI8) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<i8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroI8) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<i16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroI16) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<i16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroI16) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<i32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroI32) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<i32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroI32) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<i64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroI64) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<i64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroI64) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<isize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroIsize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<isize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroIsize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<u8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroU8) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<u8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroU8) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<u16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroU16) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<u16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroU16) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<u32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroU32) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<u32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroU32) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<u64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroU64) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<u64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroU64) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<usize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroUsize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZero<usize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroUsize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<NonZeroUbig<S>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: NonZeroUbig<S>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<One> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, _: One) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<Option<&Ratio<Sign, Ubig<S>, NonZeroUbig<S>>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: Option<&Big<S>>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<Option<&Ratio<Sign, Ubig<S>, NonZeroUbig<S>>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: Option<&Big<S>>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<Option<&Ratio<Sign, u8, u8>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: Option<&Rational8>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<Option<&Ratio<Sign, u8, u8>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: Option<&Rational8>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<Option<&Ratio<Sign, u16, u16>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: Option<&Rational16>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<Option<&Ratio<Sign, u16, u16>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: Option<&Rational16>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<Option<&Ratio<Sign, u32, u32>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: Option<&Rational32>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<Option<&Ratio<Sign, u32, u32>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: Option<&Rational32>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<Option<&Ratio<Sign, u64, u64>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: Option<&Rational64>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<Option<&Ratio<Sign, u64, u64>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: Option<&Rational64>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<Ubig<S>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: Ubig<S>) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<Zero> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, _: Zero) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<i8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<i8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<i16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<i16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<i32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<i32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<i64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<i64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<isize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<isize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<u8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<u8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<u16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<u16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<u32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<u32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<u64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<u64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<usize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self::Output

Performs the + operation.

impl<const S: usize> Add<usize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self::Output

Performs the + operation.

impl<const S: usize> AddAssign for Big<S>

fn add_assign(&mut self, rhs: Big<S>)

Performs the += operation.

impl<const S: usize> AddAssign<&Binary> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&NonZero<i8>> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&NonZero<i16>> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&NonZero<i32>> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&NonZero<i64>> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&NonZero<isize>> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&NonZero<u8>> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&NonZero<u16>> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&NonZero<u32>> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&NonZero<u64>> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&NonZero<usize>> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&NonZeroUbig<S>> for Big<S>

fn add_assign(&mut self, rhs: &NonZeroUbig<S>)

Performs the += operation.

impl<const S: usize> AddAssign<&One> for Big<S>

fn add_assign(&mut self, _: &One)

Performs the += operation.

impl<const S: usize> AddAssign<&Ubig<S>> for Big<S>

fn add_assign(&mut self, rhs: &Ubig<S>)

Performs the += operation.

impl<const S: usize> AddAssign<&Zero> for Big<S>

fn add_assign(&mut self, _: &Zero)

Performs the += operation.

impl<const S: usize> AddAssign<&i8> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&i16> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&i32> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&i64> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&isize> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&u8> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&u16> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&u32> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&u64> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<&usize> for Big<S>

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

Performs the += operation.

impl<const S: usize> AddAssign<Binary> for Big<S>

fn add_assign(&mut self, rhs: Binary)

Performs the += operation.

impl<const S: usize> AddAssign<NonZero<i8>> for Big<S>

fn add_assign(&mut self, rhs: NonZeroI8)

Performs the += operation.

impl<const S: usize> AddAssign<NonZero<i16>> for Big<S>

fn add_assign(&mut self, rhs: NonZeroI16)

Performs the += operation.

impl<const S: usize> AddAssign<NonZero<i32>> for Big<S>

fn add_assign(&mut self, rhs: NonZeroI32)

Performs the += operation.

impl<const S: usize> AddAssign<NonZero<i64>> for Big<S>

fn add_assign(&mut self, rhs: NonZeroI64)

Performs the += operation.

impl<const S: usize> AddAssign<NonZero<isize>> for Big<S>

fn add_assign(&mut self, rhs: NonZeroIsize)

Performs the += operation.

impl<const S: usize> AddAssign<NonZero<u8>> for Big<S>

fn add_assign(&mut self, rhs: NonZeroU8)

Performs the += operation.

impl<const S: usize> AddAssign<NonZero<u16>> for Big<S>

fn add_assign(&mut self, rhs: NonZeroU16)

Performs the += operation.

impl<const S: usize> AddAssign<NonZero<u32>> for Big<S>

fn add_assign(&mut self, rhs: NonZeroU32)

Performs the += operation.

impl<const S: usize> AddAssign<NonZero<u64>> for Big<S>

fn add_assign(&mut self, rhs: NonZeroU64)

Performs the += operation.

impl<const S: usize> AddAssign<NonZero<usize>> for Big<S>

fn add_assign(&mut self, rhs: NonZeroUsize)

Performs the += operation.

impl<const S: usize> AddAssign<NonZeroUbig<S>> for Big<S>

fn add_assign(&mut self, rhs: NonZeroUbig<S>)

Performs the += operation.

impl<const S: usize> AddAssign<One> for Big<S>

fn add_assign(&mut self, _: One)

Performs the += operation.

impl<const S: usize> AddAssign<Ubig<S>> for Big<S>

fn add_assign(&mut self, rhs: Ubig<S>)

Performs the += operation.

impl<const S: usize> AddAssign<Zero> for Big<S>

fn add_assign(&mut self, _: Zero)

Performs the += operation.

impl<const S: usize> AddAssign<i8> for Big<S>

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<const S: usize> AddAssign<i16> for Big<S>

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<const S: usize> AddAssign<i32> for Big<S>

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<const S: usize> AddAssign<i64> for Big<S>

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<const S: usize> AddAssign<isize> for Big<S>

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

impl<const S: usize> AddAssign<u8> for Big<S>

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<const S: usize> AddAssign<u16> for Big<S>

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<const S: usize> AddAssign<u32> for Big<S>

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<const S: usize> AddAssign<u64> for Big<S>

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<const S: usize> AddAssign<usize> for Big<S>

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl<const S: usize> Debug for Big<S>

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

Formats the value using the given formatter.

impl<const S: usize> Default for Big<S>

fn default() -> Self

Returns the “default value” for a type.

impl<const S: usize> Display for Big<S>

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

Formats the value using the given formatter.

impl<const S: usize> Div for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: Big<S>) -> Self::Output

Performs the / operation.

impl<const S: usize> Div for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &Big<S>) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&Binary> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &Binary) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&Binary> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &Binary) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<i8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroI8) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<i8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroI8) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<i16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroI16) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<i16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroI16) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<i32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroI32) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<i32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroI32) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<i64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroI64) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<i64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroI64) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<isize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroIsize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<isize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroIsize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<u8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroU8) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<u8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroU8) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<u16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroU16) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<u16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroU16) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<u32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroU32) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<u32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroU32) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<u64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroU64) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<u64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroU64) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<usize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroUsize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&NonZero<usize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZeroUsize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&One> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, _: &One) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&One> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, _: &One) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&i8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&i8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&i16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&i16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&i32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&i32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&i64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&i64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&isize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&isize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&u8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&u8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&u16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&u16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&u32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&u32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&u64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&u64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const S: usize> Div<&usize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<&usize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<Binary> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: Binary) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<Binary> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: Binary) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<i8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroI8) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<i8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroI8) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<i16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroI16) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<i16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroI16) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<i32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroI32) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<i32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroI32) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<i64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroI64) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<i64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroI64) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<isize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroIsize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<isize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroIsize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<u8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroU8) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<u8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroU8) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<u16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroU16) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<u16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroU16) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<u32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroU32) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<u32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroU32) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<u64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroU64) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<u64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroU64) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<usize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroUsize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZero<usize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroUsize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<NonZeroUbig<S>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: NonZeroUbig<S>) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<One> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, _: One) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<One> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, _: One) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<Ubig<S>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: Ubig<S>) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<i8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<i8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<i16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<i16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<i32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<i32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<i64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<i64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<isize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<isize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<u8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<u8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<u16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<u16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<u32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<u32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<u64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<u64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<usize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> Self::Output

Performs the / operation.

impl<const S: usize> Div<usize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> Self::Output

Performs the / operation.

impl<const S: usize> DivAssign for Big<S>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const S: usize> DivAssign<&Binary> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&NonZero<i8>> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&NonZero<i16>> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&NonZero<i32>> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&NonZero<i64>> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&NonZero<isize>> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&NonZero<u8>> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&NonZero<u16>> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&NonZero<u32>> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&NonZero<u64>> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&NonZero<usize>> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&NonZeroUbig<S>> for Big<S>

fn div_assign(&mut self, rhs: &NonZeroUbig<S>)

Performs the /= operation.

impl<const S: usize> DivAssign<&One> for Big<S>

fn div_assign(&mut self, _: &One)

Performs the /= operation.

impl<const S: usize> DivAssign<&i8> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&i16> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&i32> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&i64> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&isize> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&u8> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&u16> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&u32> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&u64> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&usize> for Big<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<Binary> for Big<S>

fn div_assign(&mut self, rhs: Binary)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<i8>> for Big<S>

fn div_assign(&mut self, rhs: NonZeroI8)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<i16>> for Big<S>

fn div_assign(&mut self, rhs: NonZeroI16)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<i32>> for Big<S>

fn div_assign(&mut self, rhs: NonZeroI32)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<i64>> for Big<S>

fn div_assign(&mut self, rhs: NonZeroI64)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<isize>> for Big<S>

fn div_assign(&mut self, rhs: NonZeroIsize)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<u8>> for Big<S>

fn div_assign(&mut self, rhs: NonZeroU8)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<u16>> for Big<S>

fn div_assign(&mut self, rhs: NonZeroU16)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<u32>> for Big<S>

fn div_assign(&mut self, rhs: NonZeroU32)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<u64>> for Big<S>

fn div_assign(&mut self, rhs: NonZeroU64)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<usize>> for Big<S>

fn div_assign(&mut self, rhs: NonZeroUsize)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZeroUbig<S>> for Big<S>

fn div_assign(&mut self, rhs: NonZeroUbig<S>)

Performs the /= operation.

impl<const S: usize> DivAssign<One> for Big<S>

fn div_assign(&mut self, _: One)

Performs the /= operation.

impl<const S: usize> DivAssign<Ubig<S>> for Big<S>

fn div_assign(&mut self, rhs: Ubig<S>)

Performs the /= operation.

impl<const S: usize> DivAssign<i8> for Big<S>

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<const S: usize> DivAssign<i16> for Big<S>

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<const S: usize> DivAssign<i32> for Big<S>

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<const S: usize> DivAssign<i64> for Big<S>

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<const S: usize> DivAssign<isize> for Big<S>

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl<const S: usize> DivAssign<u8> for Big<S>

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<const S: usize> DivAssign<u16> for Big<S>

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<const S: usize> DivAssign<u32> for Big<S>

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<const S: usize> DivAssign<u64> for Big<S>

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<const S: usize> DivAssign<usize> for Big<S>

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl<const S: usize> EncodingSize for Big<S>

fn numerator_bits(&self) -> u32

Bits in the numerator.

fn denominator_bits(&self) -> u32

Bits in the denominator.

fn encoding_bits(&self) -> u64

What it costs to store this value.

impl<const S: usize> Eq for Big<S>

impl<const S: usize> From<&Binary> for Big<S>

fn from(from: &Binary) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&NonZero<i8>> for Big<S>

fn from(other: &NonZeroI8) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&NonZero<i16>> for Big<S>

fn from(other: &NonZeroI16) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&NonZero<i32>> for Big<S>

fn from(other: &NonZeroI32) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&NonZero<i64>> for Big<S>

fn from(other: &NonZeroI64) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&NonZero<u8>> for Big<S>

fn from(other: &NonZeroU8) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&NonZero<u16>> for Big<S>

fn from(other: &NonZeroU16) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&NonZero<u32>> for Big<S>

fn from(other: &NonZeroU32) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&NonZero<u64>> for Big<S>

fn from(other: &NonZeroU64) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&One> for Big<S>

fn from(_: &One) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&Zero> for Big<S>

fn from(_: &Zero) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&i8> for Big<S>

fn from(other: &i8) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&i16> for Big<S>

fn from(other: &i16) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&i32> for Big<S>

fn from(other: &i32) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&i64> for Big<S>

fn from(other: &i64) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&u8> for Big<S>

fn from(other: &u8) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&u16> for Big<S>

fn from(other: &u16) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&u32> for Big<S>

fn from(other: &u32) -> Self

Converts to this type from the input type.

impl<const S: usize> From<&u64> for Big<S>

fn from(other: &u64) -> Self

Converts to this type from the input type.

impl<const S: usize> From<(i8, i8)> for Big<S>

fn from((numerator, denominator): (i8, i8)) -> Self

Converts to this type from the input type.

impl<const S: usize> From<(i8, u8)> for Big<S>

fn from((numerator, denominator): (i8, u8)) -> Self

Converts to this type from the input type.

impl<const S: usize> From<(i16, i16)> for Big<S>

fn from((numerator, denominator): (i16, i16)) -> Self

Converts to this type from the input type.

impl<const S: usize> From<(i16, u16)> for Big<S>

fn from((numerator, denominator): (i16, u16)) -> Self

Converts to this type from the input type.

impl<const S: usize> From<(i32, i32)> for Big<S>

fn from((numerator, denominator): (i32, i32)) -> Self

Converts to this type from the input type.

impl<const S: usize> From<(i32, u32)> for Big<S>

fn from((numerator, denominator): (i32, u32)) -> Self

Converts to this type from the input type.

impl<const S: usize> From<(i64, i64)> for Big<S>

fn from((numerator, denominator): (i64, i64)) -> Self

Converts to this type from the input type.

impl<const S: usize> From<(i64, u64)> for Big<S>

fn from((numerator, denominator): (i64, u64)) -> Self

Converts to this type from the input type.

impl<const S: usize> From<(i128, i128)> for Big<S>

fn from((numerator, denominator): (i128, i128)) -> Self

Converts to this type from the input type.

impl<const S: usize> From<(i128, u128)> for Big<S>

fn from((numerator, denominator): (i128, u128)) -> Self

Converts to this type from the input type.

impl<const S: usize> From<(isize, isize)> for Big<S>

fn from((numerator, denominator): (isize, isize)) -> Self

Converts to this type from the input type.

impl<const S: usize> From<Binary> for Big<S>

fn from(from: Binary) -> Self

Converts to this type from the input type.

impl<const S: usize> From<NonZero<i8>> for Big<S>

fn from(value: NonZeroI8) -> Self

Converts to this type from the input type.

impl<const S: usize> From<NonZero<i16>> for Big<S>

fn from(value: NonZeroI16) -> Self

Converts to this type from the input type.

impl<const S: usize> From<NonZero<i32>> for Big<S>

fn from(value: NonZeroI32) -> Self

Converts to this type from the input type.

impl<const S: usize> From<NonZero<i64>> for Big<S>

fn from(value: NonZeroI64) -> Self

Converts to this type from the input type.

impl<const S: usize> From<NonZero<isize>> for Big<S>

fn from(value: NonZeroIsize) -> Self

Converts to this type from the input type.

impl<const S: usize> From<NonZero<u8>> for Big<S>

fn from(value: NonZeroU8) -> Self

Converts to this type from the input type.

impl<const S: usize> From<NonZero<u16>> for Big<S>

fn from(value: NonZeroU16) -> Self

Converts to this type from the input type.

impl<const S: usize> From<NonZero<u32>> for Big<S>

fn from(value: NonZeroU32) -> Self

Converts to this type from the input type.

impl<const S: usize> From<NonZero<u64>> for Big<S>

fn from(value: NonZeroU64) -> Self

Converts to this type from the input type.

impl<const S: usize> From<NonZero<usize>> for Big<S>

fn from(value: NonZeroUsize) -> Self

Converts to this type from the input type.

impl<const S: usize> From<One> for Big<S>

fn from(_: One) -> Self

Converts to this type from the input type.

impl<const S: usize> From<Zero> for Big<S>

fn from(_: Zero) -> Self

Converts to this type from the input type.

impl<const S: usize> From<i8> for Big<S>

fn from(value: i8) -> Self

Converts to this type from the input type.

impl<const S: usize> From<i16> for Big<S>

fn from(value: i16) -> Self

Converts to this type from the input type.

impl<const S: usize> From<i32> for Big<S>

fn from(value: i32) -> Self

Converts to this type from the input type.

impl<const S: usize> From<i64> for Big<S>

fn from(value: i64) -> Self

Converts to this type from the input type.

impl<const S: usize> From<isize> for Big<S>

fn from(value: isize) -> Self

Converts to this type from the input type.

impl<const S: usize> From<u8> for Big<S>

fn from(value: u8) -> Self

Converts to this type from the input type.

impl<const S: usize> From<u16> for Big<S>

fn from(value: u16) -> Self

Converts to this type from the input type.

impl<const S: usize> From<u32> for Big<S>

fn from(value: u32) -> Self

Converts to this type from the input type.

impl<const S: usize> From<u64> for Big<S>

fn from(value: u64) -> Self

Converts to this type from the input type.

impl<const S: usize> From<usize> for Big<S>

fn from(value: usize) -> Self

Converts to this type from the input type.

impl<const S: usize> FromPrimitive for Big<S>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<const S: usize> FromStr for Big<S>

type Err = &'static str

The associated error which can be returned from parsing.

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

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

impl<const S: usize> Gcd for Big<S>

Never fails: the numerator of the result divides both numerators and the denominator is a product of the two denominators, and neither can run out of room.

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

The greatest common divisor of two numbers.

impl<const S: usize> Mul for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&Binary> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Binary) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&Binary> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &Binary) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<i8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroI8) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<i8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroI8) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<i16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroI16) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<i16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroI16) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<i32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroI32) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<i32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroI32) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<i64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroI64) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<i64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroI64) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<isize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroIsize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<isize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroIsize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<u8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroU8) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<u8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroU8) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<u16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroU16) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<u16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroU16) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<u32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroU32) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<u32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroU32) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<u64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroU64) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<u64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroU64) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<usize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroUsize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<usize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroUsize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&One> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, _: &One) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&One> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, _: &One) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&Zero> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, _: &Zero) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&Zero> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, _: &Zero) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&i8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&i8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&i16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&i16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&i32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&i32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&i64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&i64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&isize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&isize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&u8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&u8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&u16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&u16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&u32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&u32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&u64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&u64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const S: usize> Mul<&usize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&usize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Binary> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: Binary) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Binary> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: Binary) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<i8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroI8) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<i8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroI8) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<i16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroI16) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<i16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroI16) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<i32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroI32) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<i32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroI32) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<i64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroI64) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<i64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroI64) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<isize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroIsize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<isize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroIsize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<u8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroU8) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<u8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroU8) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<u16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroU16) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<u16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroU16) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<u32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroU32) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<u32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroU32) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<u64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroU64) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<u64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroU64) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<usize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroUsize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZero<usize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroUsize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<NonZeroUbig<S>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroUbig<S>) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<One> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, _: One) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<One> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, _: One) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Option<&Ratio<Sign, Ubig<S>, NonZeroUbig<S>>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<&Big<S>>) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Option<&Ratio<Sign, Ubig<S>, NonZeroUbig<S>>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<&Big<S>>) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Option<&Ratio<Sign, u8, u8>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<&Rational8>) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Option<&Ratio<Sign, u8, u8>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<&Rational8>) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Option<&Ratio<Sign, u16, u16>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<&Rational16>) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Option<&Ratio<Sign, u16, u16>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<&Rational16>) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Option<&Ratio<Sign, u32, u32>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<&Rational32>) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Option<&Ratio<Sign, u32, u32>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<&Rational32>) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Option<&Ratio<Sign, u64, u64>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<&Rational64>) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Option<&Ratio<Sign, u64, u64>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: Option<&Rational64>) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Ubig<S>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: Ubig<S>) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Zero> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, _: Zero) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<Zero> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, _: Zero) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<i8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<i8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<i16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<i16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<i32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<i32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<i64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<i64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<isize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<isize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<u8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<u8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<u16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<u16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<u32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<u32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<u64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<u64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<usize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<usize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self::Output

Performs the * operation.

impl<const S: usize> MulAssign for Big<S>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const S: usize> MulAssign<&Binary> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<i8>> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<i16>> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<i32>> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<i64>> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<isize>> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<u8>> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<u16>> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<u32>> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<u64>> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<usize>> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZeroUbig<S>> for Big<S>

fn mul_assign(&mut self, rhs: &NonZeroUbig<S>)

Performs the *= operation.

impl<const S: usize> MulAssign<&One> for Big<S>

fn mul_assign(&mut self, _: &One)

Performs the *= operation.

impl<const S: usize> MulAssign<&Zero> for Big<S>

fn mul_assign(&mut self, _: &Zero)

Performs the *= operation.

impl<const S: usize> MulAssign<&i8> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&i16> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&i32> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&i64> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&isize> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&u8> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&u16> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&u32> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&u64> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&usize> for Big<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<Binary> for Big<S>

fn mul_assign(&mut self, rhs: Binary)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<i8>> for Big<S>

fn mul_assign(&mut self, rhs: NonZeroI8)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<i16>> for Big<S>

fn mul_assign(&mut self, rhs: NonZeroI16)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<i32>> for Big<S>

fn mul_assign(&mut self, rhs: NonZeroI32)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<i64>> for Big<S>

fn mul_assign(&mut self, rhs: NonZeroI64)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<isize>> for Big<S>

fn mul_assign(&mut self, rhs: NonZeroIsize)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<u8>> for Big<S>

fn mul_assign(&mut self, rhs: NonZeroU8)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<u16>> for Big<S>

fn mul_assign(&mut self, rhs: NonZeroU16)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<u32>> for Big<S>

fn mul_assign(&mut self, rhs: NonZeroU32)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<u64>> for Big<S>

fn mul_assign(&mut self, rhs: NonZeroU64)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<usize>> for Big<S>

fn mul_assign(&mut self, rhs: NonZeroUsize)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZeroUbig<S>> for Big<S>

fn mul_assign(&mut self, rhs: NonZeroUbig<S>)

Performs the *= operation.

impl<const S: usize> MulAssign<One> for Big<S>

fn mul_assign(&mut self, _: One)

Performs the *= operation.

impl<const S: usize> MulAssign<Ubig<S>> for Big<S>

fn mul_assign(&mut self, rhs: Ubig<S>)

Performs the *= operation.

impl<const S: usize> MulAssign<Zero> for Big<S>

fn mul_assign(&mut self, _: Zero)

Performs the *= operation.

impl<const S: usize> MulAssign<i8> for Big<S>

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const S: usize> MulAssign<i16> for Big<S>

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const S: usize> MulAssign<i32> for Big<S>

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const S: usize> MulAssign<i64> for Big<S>

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const S: usize> MulAssign<isize> for Big<S>

fn mul_assign(&mut self, rhs: isize)

Performs the *= operation.

impl<const S: usize> MulAssign<u8> for Big<S>

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const S: usize> MulAssign<u16> for Big<S>

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const S: usize> MulAssign<u32> for Big<S>

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const S: usize> MulAssign<u64> for Big<S>

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const S: usize> MulAssign<usize> for Big<S>

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl<const S: usize> Neg for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const S: usize> Neg for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const S: usize> One for Big<S>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

impl<const S: usize> Ord for Big<S>

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl<const S: usize> PartialEq for Big<S>

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<const S: usize> PartialOrd for Big<S>

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

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl<const S: usize> Sub for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: Big<S>) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const S: usize> Sub<&Binary> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &Binary) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<i8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroI8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<i8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroI8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<i16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroI16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<i16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroI16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<i32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroI32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<i32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroI32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<i64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroI64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<i64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroI64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<isize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroIsize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<isize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroIsize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<u8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroU8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<u8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroU8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<u16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroU16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<u16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroU16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<u32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroU32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<u32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroU32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<u64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroU64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<u64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroU64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<usize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroUsize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZero<usize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroUsize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&NonZeroUbig<S>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZeroUbig<S>) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&One> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, _: &One) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&Ubig<S>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &Ubig<S>) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&Zero> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, _: &Zero) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&i8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&i8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&i16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&i16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&i32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&i32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&i64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&i64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&isize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&isize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&u8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&u8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&u16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&u16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&u32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&u32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&u64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&u64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&usize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<&usize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<Binary> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: Binary) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<i8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroI8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<i8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroI8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<i16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroI16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<i16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroI16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<i32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroI32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<i32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroI32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<i64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroI64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<i64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroI64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<isize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroIsize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<isize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroIsize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<u8>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroU8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<u8>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroU8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<u16>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroU16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<u16>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroU16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<u32>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroU32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<u32>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroU32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<u64>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroU64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<u64>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroU64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<usize>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroUsize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZero<usize>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroUsize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<NonZeroUbig<S>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZeroUbig<S>) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<One> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, _: One) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<Option<&Ratio<Sign, u8, u8>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<&Rational8>) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<Option<&Ratio<Sign, u8, u8>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<&Rational8>) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<Option<&Ratio<Sign, u16, u16>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<&Rational16>) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<Option<&Ratio<Sign, u16, u16>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<&Rational16>) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<Option<&Ratio<Sign, u32, u32>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<&Rational32>) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<Option<&Ratio<Sign, u32, u32>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<&Rational32>) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<Option<&Ratio<Sign, u64, u64>>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<&Rational64>) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<Option<&Ratio<Sign, u64, u64>>> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: Option<&Rational64>) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<Ubig<S>> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: Ubig<S>) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<Zero> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, _: Zero) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<i8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<i8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<i16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<i16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<i32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<i32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<i64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<i64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<isize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<isize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<u8> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<u8> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<u16> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<u16> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<u32> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<u32> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<u64> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<u64> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<usize> for Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self::Output

Performs the - operation.

impl<const S: usize> Sub<usize> for &Big<S>

type Output = Ratio<Sign, Ubig<S>, NonZeroUbig<S>>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self::Output

Performs the - operation.

impl<const S: usize> SubAssign for Big<S>

fn sub_assign(&mut self, rhs: Big<S>)

Performs the -= operation.

impl<const S: usize> SubAssign<&Binary> for Big<S>

fn sub_assign(&mut self, rhs: &Binary)

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<i8>> for Big<S>

fn sub_assign(&mut self, rhs: &NonZeroI8)

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<i16>> for Big<S>

fn sub_assign(&mut self, rhs: &NonZeroI16)

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<i32>> for Big<S>

fn sub_assign(&mut self, rhs: &NonZeroI32)

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<i64>> for Big<S>

fn sub_assign(&mut self, rhs: &NonZeroI64)

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<isize>> for Big<S>

fn sub_assign(&mut self, rhs: &NonZeroIsize)

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<u8>> for Big<S>

fn sub_assign(&mut self, rhs: &NonZeroU8)

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<u16>> for Big<S>

fn sub_assign(&mut self, rhs: &NonZeroU16)

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<u32>> for Big<S>

fn sub_assign(&mut self, rhs: &NonZeroU32)

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<u64>> for Big<S>

fn sub_assign(&mut self, rhs: &NonZeroU64)

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<usize>> for Big<S>

fn sub_assign(&mut self, rhs: &NonZeroUsize)

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZeroUbig<S>> for Big<S>

fn sub_assign(&mut self, rhs: &NonZeroUbig<S>)

Performs the -= operation.

impl<const S: usize> SubAssign<&One> for Big<S>

fn sub_assign(&mut self, _: &One)

Performs the -= operation.

impl<const S: usize> SubAssign<&Ubig<S>> for Big<S>

fn sub_assign(&mut self, rhs: &Ubig<S>)

Performs the -= operation.

impl<const S: usize> SubAssign<&Zero> for Big<S>

fn sub_assign(&mut self, _: &Zero)

Performs the -= operation.

impl<const S: usize> SubAssign<&i8> for Big<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&i16> for Big<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&i32> for Big<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&i64> for Big<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&isize> for Big<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&u8> for Big<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&u16> for Big<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&u32> for Big<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&u64> for Big<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&usize> for Big<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<Binary> for Big<S>

fn sub_assign(&mut self, rhs: Binary)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<i8>> for Big<S>

fn sub_assign(&mut self, rhs: NonZeroI8)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<i16>> for Big<S>

fn sub_assign(&mut self, rhs: NonZeroI16)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<i32>> for Big<S>

fn sub_assign(&mut self, rhs: NonZeroI32)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<i64>> for Big<S>

fn sub_assign(&mut self, rhs: NonZeroI64)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<isize>> for Big<S>

fn sub_assign(&mut self, rhs: NonZeroIsize)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<u8>> for Big<S>

fn sub_assign(&mut self, rhs: NonZeroU8)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<u16>> for Big<S>

fn sub_assign(&mut self, rhs: NonZeroU16)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<u32>> for Big<S>

fn sub_assign(&mut self, rhs: NonZeroU32)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<u64>> for Big<S>

fn sub_assign(&mut self, rhs: NonZeroU64)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<usize>> for Big<S>

fn sub_assign(&mut self, rhs: NonZeroUsize)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZeroUbig<S>> for Big<S>

fn sub_assign(&mut self, rhs: NonZeroUbig<S>)

Performs the -= operation.

impl<const S: usize> SubAssign<One> for Big<S>

fn sub_assign(&mut self, _: One)

Performs the -= operation.

impl<const S: usize> SubAssign<Ubig<S>> for Big<S>

fn sub_assign(&mut self, rhs: Ubig<S>)

Performs the -= operation.

impl<const S: usize> SubAssign<Zero> for Big<S>

fn sub_assign(&mut self, _: Zero)

Performs the -= operation.

impl<const S: usize> SubAssign<i8> for Big<S>

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const S: usize> SubAssign<i16> for Big<S>

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const S: usize> SubAssign<i32> for Big<S>

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const S: usize> SubAssign<i64> for Big<S>

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const S: usize> SubAssign<isize> for Big<S>

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl<const S: usize> SubAssign<u8> for Big<S>

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const S: usize> SubAssign<u16> for Big<S>

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const S: usize> SubAssign<u32> for Big<S>

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const S: usize> SubAssign<u64> for Big<S>

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const S: usize> SubAssign<usize> for Big<S>

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

impl<const S: usize> Sum for Big<S>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<const S: usize> ToPrimitive for Big<S>

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

impl<const S: usize, const I1: usize, const I2: usize> TryFrom<(Sign, [usize; I1], [usize; I2])> for Big<S>

type Error = ()

The type returned in the event of a conversion error.

fn try_from( (sign, numerator, denominator): (Sign, [usize; I1], [usize; I2]), ) -> Result<Self, Self::Error>

Performs the conversion.

impl<const S: usize> Zero for Big<S>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.