Type Alias NonZeroBig 

pub type NonZeroBig<const S: usize> = Ratio<NonZeroSign, NonZeroUbig<S>, NonZeroUbig<S>>;

An arbitrary precision rational that is known not to be zero.

Aliased Type

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

Trait Implementations

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

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<&i8> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<NonZero<i8>> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<i8> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<&NonZero<i8>> for NonZeroBig<S>

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

fn add_assign(&mut self, rhs: NonZeroI8)

Performs the += operation.

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

fn add_assign(&mut self, rhs: NonZeroI16)

Performs the += operation.

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

fn add_assign(&mut self, rhs: NonZeroI32)

Performs the += operation.

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

fn add_assign(&mut self, rhs: NonZeroI64)

Performs the += operation.

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

fn add_assign(&mut self, rhs: NonZeroIsize)

Performs the += operation.

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

fn add_assign(&mut self, rhs: NonZeroU8)

Performs the += operation.

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

fn add_assign(&mut self, rhs: NonZeroU16)

Performs the += operation.

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

fn add_assign(&mut self, rhs: NonZeroU32)

Performs the += operation.

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

fn add_assign(&mut self, rhs: NonZeroU64)

Performs the += operation.

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

fn add_assign(&mut self, rhs: NonZeroUsize)

Performs the += operation.

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

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

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

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

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

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

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

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

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

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

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

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

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

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

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

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

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

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

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

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

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

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<&i8> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<NonZero<i8>> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<i8> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

impl<const S: usize> DivAssign<&i16> for NonZeroBig<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&i32> for NonZeroBig<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&i64> for NonZeroBig<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&isize> for NonZeroBig<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&u8> for NonZeroBig<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&u16> for NonZeroBig<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&u32> for NonZeroBig<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&u64> for NonZeroBig<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<&usize> for NonZeroBig<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<i8>> for NonZeroBig<S>

fn div_assign(&mut self, rhs: NonZeroI8)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<i16>> for NonZeroBig<S>

fn div_assign(&mut self, rhs: NonZeroI16)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<i32>> for NonZeroBig<S>

fn div_assign(&mut self, rhs: NonZeroI32)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<i64>> for NonZeroBig<S>

fn div_assign(&mut self, rhs: NonZeroI64)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<isize>> for NonZeroBig<S>

fn div_assign(&mut self, rhs: NonZeroIsize)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<u8>> for NonZeroBig<S>

fn div_assign(&mut self, rhs: NonZeroU8)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<u16>> for NonZeroBig<S>

fn div_assign(&mut self, rhs: NonZeroU16)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<u32>> for NonZeroBig<S>

fn div_assign(&mut self, rhs: NonZeroU32)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<u64>> for NonZeroBig<S>

fn div_assign(&mut self, rhs: NonZeroU64)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZero<usize>> for NonZeroBig<S>

fn div_assign(&mut self, rhs: NonZeroUsize)

Performs the /= operation.

impl<const S: usize> DivAssign<NonZeroUbig<S>> for NonZeroBig<S>

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

Performs the /= operation.

impl<const S: usize> DivAssign<i8> for NonZeroBig<S>

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<const S: usize> DivAssign<i16> for NonZeroBig<S>

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<const S: usize> DivAssign<i32> for NonZeroBig<S>

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<const S: usize> DivAssign<i64> for NonZeroBig<S>

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<const S: usize> DivAssign<isize> for NonZeroBig<S>

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl<const S: usize> DivAssign<u8> for NonZeroBig<S>

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<const S: usize> DivAssign<u16> for NonZeroBig<S>

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<const S: usize> DivAssign<u32> for NonZeroBig<S>

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<const S: usize> DivAssign<u64> for NonZeroBig<S>

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

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

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl<const S: usize> Eq for NonZeroBig<S>

impl<const S: usize> Mul for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 for &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<S>, NonZeroUbig<S>>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroBig<S>) -> Self::Output

Performs the * operation.

impl<const S: usize> Mul<&NonZero<i8>> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<&i8> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<NonZero<i8>> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<i8> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<i8>> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<i16>> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<i32>> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<i64>> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<isize>> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<u8>> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<u16>> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<u32>> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<u64>> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZero<usize>> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&NonZeroUbig<S>> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&i8> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&i16> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&i32> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&i64> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&isize> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&u8> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&u16> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&u32> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&u64> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<&usize> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<i8>> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: NonZeroI8)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<i16>> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: NonZeroI16)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<i32>> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: NonZeroI32)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<i64>> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: NonZeroI64)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<isize>> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: NonZeroIsize)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<u8>> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: NonZeroU8)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<u16>> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: NonZeroU16)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<u32>> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: NonZeroU32)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<u64>> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: NonZeroU64)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZero<usize>> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: NonZeroUsize)

Performs the *= operation.

impl<const S: usize> MulAssign<NonZeroUbig<S>> for NonZeroBig<S>

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

Performs the *= operation.

impl<const S: usize> MulAssign<i8> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const S: usize> MulAssign<i16> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const S: usize> MulAssign<i32> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const S: usize> MulAssign<i64> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const S: usize> MulAssign<isize> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: isize)

Performs the *= operation.

impl<const S: usize> MulAssign<u8> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const S: usize> MulAssign<u16> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const S: usize> MulAssign<u32> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const S: usize> MulAssign<u64> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const S: usize> MulAssign<usize> for NonZeroBig<S>

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl<const S: usize> One for NonZeroBig<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 NonZeroBig<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 NonZeroBig<S>

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<const S: usize> PartialOrd for NonZeroBig<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<&NonZero<i8>> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<&i8> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<NonZero<i8>> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<i8> for NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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 &NonZeroBig<S>

type Output = Ratio<NonZeroSign, NonZeroUbig<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<&NonZero<i8>> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<i16>> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<i32>> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<i64>> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<isize>> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<u8>> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<u16>> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<u32>> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<u64>> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&NonZero<usize>> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&i8> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&i16> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&i32> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&i64> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&isize> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&u8> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&u16> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&u32> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&u64> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<&usize> for NonZeroBig<S>

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

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<i8>> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: NonZeroI8)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<i16>> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: NonZeroI16)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<i32>> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: NonZeroI32)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<i64>> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: NonZeroI64)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<isize>> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: NonZeroIsize)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<u8>> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: NonZeroU8)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<u16>> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: NonZeroU16)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<u32>> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: NonZeroU32)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<u64>> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: NonZeroU64)

Performs the -= operation.

impl<const S: usize> SubAssign<NonZero<usize>> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: NonZeroUsize)

Performs the -= operation.

impl<const S: usize> SubAssign<i8> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const S: usize> SubAssign<i16> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const S: usize> SubAssign<i32> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const S: usize> SubAssign<i64> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const S: usize> SubAssign<isize> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl<const S: usize> SubAssign<u8> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const S: usize> SubAssign<u16> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const S: usize> SubAssign<u32> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const S: usize> SubAssign<u64> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const S: usize> SubAssign<usize> for NonZeroBig<S>

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.