Type Alias NoNum

pub type NoNum = ();

Represents the absence of a number.

This can be used anywhere an implementation of Num is expected, since it implements all the numeric traits, but does nothing.

Trait Implementations

impl Num for NoNum

type Inner = ()

The internal representation of this numeric type.

type Out = ()

The output type for operations.

type Rhs = ()

The right hand side type for operations.

fn num_into(self) -> Self::Inner

Returns the inner self representation.

fn num_from(value: Self::Inner) -> Result<Self>

where Self: Sized,

Returns Self if given a valid value.

fn num_from_ref(value: &Self::Inner) -> Result<Self>

where Self: Sized,

Returns Self if given a valid &value.

fn num_set(&mut self, value: Self::Inner) -> Result<()>

Sets self to the given valid value.

fn num_set_ref(&mut self, value: &Self::Inner) -> Result<()>

Sets self to the given valid &value.

fn num_is_zero(&self) -> Result<bool>

Returns true if self is zero.

fn num_get_zero() -> Result<Self>

where Self: Sized,

Returns the number zero.

fn num_set_zero(&mut self) -> Result<()>

Sets self to 0.

fn num_is_one(&self) -> Result<bool>

Returns true if self is one.

fn num_get_one() -> Result<Self>

where Self: Sized,

Returns the number one.

fn num_set_one(&mut self) -> Result<()>

Sets the number to one.

fn num_add(self, rhs: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Computes self + rhs (addition).

fn num_ref_add(&self, rhs: &Self::Rhs) -> Result<Self::Out>

Like num_add but takes the arguments by reference.

fn num_ref_add_assign(&mut self, rhs: &Self::Rhs) -> Result<()>

Computes &mut self += rhs; (addition).

fn num_sub(self, rhs: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Computes self - rhs (subtraction).

fn num_ref_sub(&self, rhs: &Self::Rhs) -> Result<Self::Out>

Like num_sub but takes the arguments by reference.

fn num_ref_sub_assign(&mut self, rhs: &Self::Rhs) -> Result<()>

Computes &mut self -= rhs; (subtraction).

fn num_mul(self, rhs: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Computes self * rhs (multiplication).

fn num_ref_mul(&self, rhs: &Self::Rhs) -> Result<Self::Out>

Like num_mul but takes the arguments by reference.

fn num_ref_mul_assign(&mut self, rhs: &Self::Rhs) -> Result<()>

Computes &mut self *= rhs; (multiplication).

fn num_div(self, rhs: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Computes self / rhs (division).

fn num_ref_div(&self, rhs: &Self::Rhs) -> Result<Self::Out>

Like num_div but takes the arguments by reference.

fn num_ref_div_assign(&mut self, rhs: &Self::Rhs) -> Result<()>

Computes &mut self /= rhs; (division).

fn num_rem(self, rhs: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Computes self % rhs (remainder).

fn num_ref_rem(&self, rhs: &Self::Rhs) -> Result<Self::Out>

Like num_rem but takes the arguments by reference.

fn num_ref_rem_assign(&mut self, rhs: &Self::Rhs) -> Result<()>

Computes &mut self %= rhs; (remainder).

fn num_neg(self) -> Result<Self::Out>

where Self: Sized,

Computes -self (additive inverse).

fn num_ref_neg(&self) -> Result<Self::Out>

Like num_neg but takes the arguments by reference.

fn num_abs(self) -> Result<Self::Out>

where Self: Sized,

Computes |self| (absolute value).

fn num_ref_abs(&self) -> Result<Self::Out>

Like num_abs but takes the arguments by reference.

impl NumInt for NoNum

Available on _int·· only.

type OutI = ()

Specifically signed output type for some operations (▶ int_gcd_ext).

fn int_digital_root(self) -> Result<Self::Out>

where Self: Sized,

Returns the digital root in base 10.

fn int_ref_digital_root(&self) -> Result<Self::Out>

Similar to int_digital_root, but operates on references instead of values.

fn int_digital_root_base(self, base: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the digital root in the given base.

fn int_ref_digital_root_base(&self, base: &Self::Rhs) -> Result<Self::Out>

Similar to int_digital_root_base, but operates on references instead of values.

fn int_digits(self) -> Result<Self::Out>

where Self: Sized,

Returns the number of digits in base 10.

fn int_ref_digits(&self) -> Result<Self::Out>

Similar to int_digits, but operates on references instead of values.

fn int_digits_sign(self) -> Result<Self::Out>

where Self: Sized,

Returns the number of digits in base 10 including the negative sign.

fn int_ref_digits_sign(&self) -> Result<Self::Out>

Similar to int_digits_sign, but operates on references instead of values.

fn int_digits_base(self, base: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the number of digits in the given base.

fn int_ref_digits_base(&self, base: &Self::Rhs) -> Result<Self::Out>

Similar to int_digits_base, but operates on references instead of values.

fn int_digits_base_sign(self, base: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the number of digits in the given base.

fn int_ref_digits_base_sign(&self, base: &Self::Rhs) -> Result<Self::Out>

Similar to int_digits_base_sign, but operates on references instead of values.

fn int_abs(self) -> Result<Self::Out>

where Self: Sized,

Returns the absolute value.

fn int_ref_abs(&self) -> Result<Self::Out>

Similar to int_abs, but operates on references instead of values.

fn int_is_even(self) -> Result<bool>

where Self: Sized,

Returns true if self is even.

fn int_ref_is_even(&self) -> Result<bool>

Similar to int_is_even, but operates on references instead of values.

fn int_is_odd(self) -> Result<bool>

where Self: Sized,

Returns true if self is odd.

fn int_ref_is_odd(&self) -> Result<bool>

Similar to int_is_odd, but operates on references instead of values.

fn int_gcd(self, other: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the GCD.

fn int_ref_gcd(&self, other: &Self::Rhs) -> Result<Self::Out>

Similar to int_gcd, but operates on references instead of values.

fn int_gcd_ext( self, other: Self::Rhs, ) -> Result<GcdReturn<Self::Out, Self::OutI>>

where Self: Sized,

Returns the GCD and the Bézout coeficients.

fn int_ref_gcd_ext( &self, other: &Self::Rhs, ) -> Result<GcdReturn<Self::Out, Self::OutI>>

Similar to int_gcd_ext, but operates on references instead of values.

fn int_lcm(self, other: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the LCM.

fn int_ref_lcm(&self, other: &Self::Rhs) -> Result<Self::Out>

Similar to int_lcm, but operates on references instead of values.

fn int_scale( self, min: Self::Rhs, max: Self::Rhs, a: Self::Rhs, b: Self::Rhs, ) -> Result<Self::Out>

where Self: Sized,

Returns a scaled value in [min..=max] to a new range [a..=b]. If the value lies outside of [min..=max] it will result in extrapolation.

fn int_ref_scale( &self, min: &Self::Rhs, max: &Self::Rhs, a: &Self::Rhs, b: &Self::Rhs, ) -> Result<Self::Out>

Similar to int_scale, but operates on references instead of values.

fn int_scale_wrap( self, min: Self::Rhs, max: Self::Rhs, a: Self::Rhs, b: Self::Rhs, ) -> Result<Self::Out>

where Self: Sized,

Returns a scaled value between [min..=max] to a new range [a..=b].

fn int_ref_scale_wrap( &self, min: &Self::Rhs, max: &Self::Rhs, a: &Self::Rhs, b: &Self::Rhs, ) -> Result<Self::Out>

Similar to int_scale_wrap, but operates on references instead of values.

fn int_midpoint(self, other: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the midpoint of self and other.

fn int_ref_midpoint(&self, other: &Self::Rhs) -> Result<Self::Out>

Similar to int_midpoint, but operates on references instead of values.

fn int_factorial(self) -> Result<Self::Out>

where Self: Sized,

Returns the factorial.

fn int_ref_factorial(&self) -> Result<Self::Out>

Similar to int_factorial, but operates on references instead of values.

fn int_subfactorial(self) -> Result<Self::Out>

where Self: Sized,

Returns the subfactorial, or the number of derangements.

fn int_ref_subfactorial(&self) -> Result<Self::Out>

Similar to int_subfactorial, but operates on references instead of values.

fn int_combine(self, r: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the number of combinations of n items taken r at a time, unordered.

fn int_ref_combine(&self, r: &Self::Rhs) -> Result<Self::Out>

Similar to int_combine, but operates on references instead of values.

fn int_combine_rep(self, r: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the number of permutations of n items taken r at a time with repetitions, unordered.

fn int_ref_combine_rep(&self, r: &Self::Rhs) -> Result<Self::Out>

Similar to int_combine_rep, but operates on references instead of values.

fn int_permute(self, r: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the number of permutations of n items taken r at a time, ordered.

fn int_ref_permute(&self, r: &Self::Rhs) -> Result<Self::Out>

Similar to int_permute, but operates on references instead of values.

fn int_permute_rep(self, r: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the number of permutations of nitems takenr` at a time with repetitions, ordered.

fn int_ref_permute_rep(&self, r: &Self::Rhs) -> Result<Self::Out>

Similar to int_permute_rep, but operates on references instead of values.

fn int_div_rem(self, b: Self::Rhs) -> Result<[Self::Out; 2]>

where Self: Sized,

Returns the truncated quotient and the remainder.

fn int_ref_div_rem(&self, b: &Self::Rhs) -> Result<[Self::Out; 2]>

Similar to int_div_rem, but operates on references instead of values.

fn int_div_ceil(self, b: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the quotient, rounding the result towards positive infinity.

fn int_ref_div_ceil(&self, b: &Self::Rhs) -> Result<Self::Out>

Similar to int_div_ceil, but operates on references instead of values.

fn int_div_floor(self, b: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the quotient, rounding the result towards negative infinity.

fn int_ref_div_floor(&self, b: &Self::Rhs) -> Result<Self::Out>

Similar to int_div_floor, but operates on references instead of values.

fn int_div_ties_away(self, b: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the quotient, rounding ties away from zero.

fn int_ref_div_ties_away(&self, b: &Self::Rhs) -> Result<Self::Out>

Similar to int_div_ties_away, but operates on references instead of values.

fn int_div_ties_towards(self, b: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the quotient, rounding ties towards from zero.

fn int_ref_div_ties_towards(&self, b: &Self::Rhs) -> Result<Self::Out>

Similar to int_div_ties_towards, but operates on references instead of values.

fn int_div_ties_even(self, b: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the quotient, rounding ties to the nearest even number.

fn int_ref_div_ties_even(&self, b: &Self::Rhs) -> Result<Self::Out>

Similar to int_div_ties_even, but operates on references instead of values.

fn int_div_ties_odd(self, b: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Returns the quotient, rounding ties to the nearest odd number.

fn int_ref_div_ties_odd(&self, b: &Self::Rhs) -> Result<Self::Out>

Similar to int_div_ties_odd, but operates on references instead of values.

fn int_factors(self) -> Result<Vec<Self::Out>>

where Self: Sized,

Available on crate feature alloc only.

Returns the factors (including 1 and self).

fn int_ref_factors(&self) -> Result<Vec<Self::Out>>

Available on crate feature alloc only.

Similar to int_factors, but operates on references instead of values.

fn int_factors_proper(self) -> Result<Vec<Self::Out>>

where Self: Sized,

Available on crate feature alloc only.

Returns the proper factors.

fn int_ref_factors_proper(&self) -> Result<Vec<Self::Out>>

Available on crate feature alloc only.

Similar to int_factors_proper, but operates on references instead of values.

fn int_factors_prime(self) -> Result<Vec<Self::Out>>

where Self: Sized,

Available on crate feature alloc only.

Returns the prime factors.

fn int_ref_factors_prime(&self) -> Result<Vec<Self::Out>>

Available on crate feature alloc only.

Similar to int_factors_prime, but operates on references instead of values.

fn int_factors_prime_unique(self) -> Result<Vec<Self::Out>>

where Self: Sized,

Available on crate feature alloc only.

Returns the unique prime factors.

fn int_ref_factors_prime_unique(&self) -> Result<Vec<Self::Out>>

Available on crate feature alloc only.

Similar to int_factors_prime_unique, but operates on references instead of values.

fn int_factors_buf( self, fbuf: &mut [Self::Out], upfbuf: &mut [Self::Out], ) -> Result<(usize, usize)>

where Self: Sized,

Writes the factors in fbuf, and the unique prime factors in upfbuf.

fn int_ref_factors_buf( &self, fbuf: &mut [Self::Out], upfbuf: &mut [Self::Out], ) -> Result<(usize, usize)>

Similar to int_factors_buf, but operates on references instead of values.

fn int_factors_proper_buf( self, fbuf: &mut [Self], upfbuf: &mut [Self], ) -> Result<(usize, usize)>

where Self: Sized,

Writes the proper factors in fbuf, and the unique prime factors in upfbuf.

fn int_ref_factors_proper_buf( &self, fbuf: &mut [Self::Out], upfbuf: &mut [Self::Out], ) -> Result<(usize, usize)>

Similar to int_factors_proper_buf, but operates on references instead of values.

fn int_factors_prime_buf(self, buffer: &mut [Self]) -> Result<usize>

where Self: Sized,

Writes the prime factors in the given buffer.

fn int_ref_factors_prime_buf(&self, buffer: &mut [Self::Out]) -> Result<usize>

Similar to int_factors_prime_buf, but operates on references instead of values.

fn int_factors_prime_unique_buf(self, buffer: &mut [Self]) -> Result<usize>

where Self: Sized,

Writes the prime factors in the given buffer.

fn int_ref_factors_prime_unique_buf( &self, buffer: &mut [Self::Out], ) -> Result<usize>

Similar to int_factors_prime_unique_buf, but operates on references instead of values.

fn int_is_prime(self) -> Result<bool>

where Self: Sized,

Returns true if n is prime.

fn int_ref_is_prime(&self) -> Result<bool>

Similar to int_is_prime, but operates on references instead of values.

fn int_prime_nth(self) -> Result<Self::Out>

where Self: Sized,

Finds the 0-indexed nth prime number.

fn int_ref_prime_nth(&self) -> Result<Self::Out>

Similar to int_prime_nth, but operates on references instead of values.

fn int_prime_pi(self) -> Result<usize>

where Self: Sized,

Counts the number of primes upto and including n.

fn int_ref_prime_pi(&self) -> Result<usize>

Similar to int_prime_pi, but operates on references instead of values.

fn int_totient(self) -> Result<Self::Out>

where Self: Sized,

Counts the number of integers $<|n|$ that are relatively prime to n.

fn int_ref_totient(&self) -> Result<Self::Out>

Similar to int_totient, but operates on references instead of values.

fn int_is_square(self) -> Result<bool>

where Self: Sized,

Returns true if it’s a perfect square.

fn int_ref_is_square(&self) -> Result<bool>

Similar to int_is_square, but operates on references instead of values.

fn int_sqrt_ceil(self) -> Result<Self::Out>

where Self: Sized,

Returns the ceiled integer square root.

fn int_ref_sqrt_ceil(&self) -> Result<Self::Out>

Similar to int_sqrt_ceil, but operates on references instead of values.

fn int_sqrt_floor(self) -> Result<Self::Out>

where Self: Sized,

Returns the floored integer square root.

fn int_ref_sqrt_floor(&self) -> Result<Self::Out>

Similar to int_sqrt_floor, but operates on references instead of values.

fn int_sqrt_round(self) -> Result<Self::Out>

where Self: Sized,

Returns the rounded integer square root.

fn int_ref_sqrt_round(&self) -> Result<Self::Out>

Similar to int_sqrt_round, but operates on references instead of values.

fn int_root_ceil(self, nth: u32) -> Result<Self::Out>

where Self: Sized,

Returns the ceiled integer nth root.

fn int_ref_root_ceil(&self, nth: u32) -> Result<Self::Out>

Similar to int_root_ceil, but operates on references instead of values.

fn int_root_floor(self, nth: u32) -> Result<Self::Out>

where Self: Sized,

Returns the floored integer nth root.

fn int_ref_root_floor(&self, nth: u32) -> Result<Self::Out>

Similar to int_root_floor, but operates on references instead of values.

fn int_modulo(self, modulus: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Computes the non-negative modulo of self over |modulus|.

fn int_ref_modulo(&self, modulus: &Self::Rhs) -> Result<Self::Out>

Similar to int_modulo, but operates on references instead of values.

fn int_modulo_cycles( self, modulus: Self::Rhs, ) -> Result<ValueQuant<Self::Out, Self::Out>>

where Self: Sized,

Computes the non-negative modulo of self over |modulus|, and the number of cycles it is reduced.

fn int_ref_modulo_cycles( &self, modulus: &Self::Rhs, ) -> Result<ValueQuant<Self::Out, Self::Out>>

where Self: Sized,

Similar to int_modulo_cycles, but operates on references instead of values.

fn int_modulo_add( self, other: Self::Rhs, modulus: Self::Rhs, ) -> Result<Self::Out>

where Self: Sized,

Computes the modulo of self + other over |modulus|.

fn int_ref_modulo_add( &self, other: &Self::Rhs, modulus: &Self::Rhs, ) -> Result<Self::Out>

Similar to int_modulo_add, but operates on references instead of values.

fn int_modulo_add_cycles( self, other: Self::Rhs, modulus: Self::Rhs, ) -> Result<ValueQuant<Self::Out, Self::Out>>

where Self: Sized,

Computes the modulo of self + other over |modulus|, and the number of cycles the result is reduced.

fn int_ref_modulo_add_cycles( &self, other: &Self::Rhs, modulus: &Self::Rhs, ) -> Result<ValueQuant<Self::Out, Self::Out>>

where Self: Sized,

Similar to int_modulo_add_cycles, but operates on references instead of values.

fn int_modulo_add_inv(self, modulus: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Calculates the modular additive inverse.

fn int_ref_modulo_add_inv(&self, modulus: &Self::Rhs) -> Result<Self::Out>

Similar to int_modulo_add_inv, but operates on references instead of values.

fn int_modulo_sub( self, other: Self::Rhs, modulus: Self::Rhs, ) -> Result<Self::Out>

where Self: Sized,

Computes the modulo of self - other over |modulus|.

fn int_ref_modulo_sub( &self, other: &Self::Rhs, modulus: &Self::Rhs, ) -> Result<Self::Out>

Similar to int_modulo_sub, but operates on references instead of values.

fn int_modulo_sub_cycles( self, other: Self::Rhs, modulus: Self::Rhs, ) -> Result<ValueQuant<Self::Out, Self::Out>>

where Self: Sized,

Computes the modulo of self - other over |modulus|, and the number of cycles the result is reduced.

fn int_ref_modulo_sub_cycles( &self, other: &Self::Rhs, modulus: &Self::Rhs, ) -> Result<ValueQuant<Self::Out, Self::Out>>

where Self: Sized,

Similar to int_modulo_sub_cycles, but operates on references instead of values.

fn int_modulo_mul( self, other: Self::Rhs, modulus: Self::Rhs, ) -> Result<Self::Out>

where Self: Sized,

Computes the modulo of self + other over |modulus|.

fn int_ref_modulo_mul( &self, other: &Self::Rhs, modulus: &Self::Rhs, ) -> Result<Self::Out>

Similar to int_modulo_mul, but operates on references instead of values.

fn int_modulo_mul_cycles( self, other: Self::Rhs, modulus: Self::Rhs, ) -> Result<ValueQuant<Self::Out, Self::Out>>

where Self: Sized,

Computes the modulo of self + other over |modulus|, and the number of cycles the result is reduced.

fn int_ref_modulo_mul_cycles( &self, other: &Self::Rhs, modulus: &Self::Rhs, ) -> Result<ValueQuant<Self::Out, Self::Out>>

where Self: Sized,

Similar to int_modulo_mul_cycles, but operates on references instead of values.

fn int_modulo_mul_inv(self, modulus: Self::Rhs) -> Result<Self::Out>

where Self: Sized,

Calculates the modular multiplicative inverse.

fn int_ref_modulo_mul_inv(&self, modulus: &Self::Rhs) -> Result<Self::Out>

Similar to int_modulo_mul_inv, but operates on references instead of values.

fn int_modulo_div( self, other: Self::Rhs, modulus: Self::Rhs, ) -> Result<Self::Out>

where Self: Sized,

Computes self / other over |modulus|.

fn int_ref_modulo_div( &self, other: &Self::Rhs, modulus: &Self::Rhs, ) -> Result<Self::Out>

Similar to int_modulo_div, but operates on references instead of values.