Struct Relaxed

pub struct Relaxed(/* private fields */);

An arbitrary precision rational number without strict reduction.

This struct is almost the same as RBig, except for that the numerator and the denominator are allowed to have common divisors other than a power of 2. This allows faster computation because Gcd is not required for each operation.

Since the representation is not canonicalized, Hash is not implemented for Relaxed. Please use RBig if you want to store the rational number in a hash set, or use num_order::NumHash.

Conversion from/to RBig

To convert from RBig, use RBig::relax(). To convert to RBig, use Relaxed::canonicalize().

Implementations

impl Relaxed

pub fn to_f32_fast(&self) -> f32

Convert the rational number to a f32.

See RBig::to_f32_fast for details.

pub fn to_f64_fast(&self) -> f64

Convert the rational number to a f64.

See RBig::to_f64_fast for details.

pub fn to_f32(&self) -> Approximation<f32, Sign>

Convert the rational number to a f32 with guaranteed correct rounding.

See RBig::to_f32 for details.

pub fn to_f64(&self) -> Approximation<f64, Sign>

Convert the rational number to a f64 with guaranteed correct rounding.

See RBig::to_f64 for details.

pub fn to_int(&self) -> Approximation<IBig, Self>

Convert the rational number to am IBig.

See RBig::to_int for details.

impl Relaxed

pub fn sqr(&self) -> Self

Compute the square of the number (self * self).

See RBig::sqr for details.

pub fn cubic(&self) -> Self

Compute the cubic of the number (self * self * self).

See RBig::cubic for details.

pub fn pow(&self, n: usize) -> Self

Raise this number to a power of n.

See RBig::pow for details.

impl Relaxed

pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseError>

Convert a string in a given base to Relaxed.

See RBig::from_str_radix for details.

pub fn from_str_with_radix_prefix(src: &str) -> Result<(Self, u32), ParseError>

Convert a string with optional radix prefixes to RBig, return the parsed integer and radix.

See RBig::from_str_with_radix_prefix for details.

impl Relaxed

pub const ZERO: Self

Relaxed with value 0

pub const ONE: Self

Relaxed with value 1

pub const NEG_ONE: Self

Relaxed with value -1

pub fn from_parts(numerator: IBig, denominator: UBig) -> Self

Create a rational number from a signed numerator and a signed denominator

See RBig::from_parts for details.

pub fn into_parts(self) -> (IBig, UBig)

Convert the rational number into (numerator, denumerator) parts.

See RBig::into_parts for details.

pub fn from_parts_signed(numerator: IBig, denominator: IBig) -> Self

Create a rational number from a signed numerator and a signed denominator

See RBig::from_parts_signed for details.

pub const fn from_parts_const( sign: Sign, numerator: DoubleWord, denominator: DoubleWord, ) -> Self

Create a rational number in a const context

See RBig::from_parts_const for details.

pub fn numerator(&self) -> &IBig

Get the numerator of the rational number

See RBig::numerator for details.

pub fn denominator(&self) -> &UBig

Get the denominator of the rational number

See RBig::denominator for details.

pub fn canonicalize(self) -> RBig

Convert this rational number into an RBig version

Examples

assert_eq!(Relaxed::ONE.canonicalize(), RBig::ONE);

let r = Relaxed::from_parts(10.into(), 5u8.into());
assert_eq!(r.canonicalize().numerator(), &IBig::from(2));

pub const fn is_zero(&self) -> bool

Check whether the number is 0

See RBig::is_zero for details.

pub fn is_one(&self) -> bool

Check whether the number is 1

See RBig::is_one for details.

impl Relaxed

pub fn split_at_point(self) -> (IBig, Self)

Split the rational number into integral and fractional parts (split at the radix point).

See RBig::split_at_point for details.

pub fn ceil(&self) -> IBig

Compute the smallest integer that is greater than this number.

See RBig::ceil for details.

pub fn floor(&self) -> IBig

Compute the largest integer that is less than or equal to this number.

See RBig::floor for details.

pub fn round(&self) -> IBig

Compute the integer that closest to this number.

See RBig::round for details.

pub fn trunc(&self) -> IBig

Returns the integral part of the rational number.

See RBig::trunc for details.

pub fn fract(&self) -> Self

Returns the fractional part of the rational number

See RBig::fract for details.

impl Relaxed

pub const fn sign(&self) -> Sign

Get the sign of the number. Zero value has a positive sign.

See RBig::sign for details.

pub const fn signum(&self) -> Self

A number representing the sign of self.

See RBig::signum for details.

impl Relaxed

pub fn to_float<R: Round, const B: Word>( &self, precision: usize, ) -> Rounded<FBig<R, B>>

Convert the rational number to a FBig with guaranteed correct rounding.

See RBig::to_float for details.

Trait Implementations

impl Abs for Relaxed

type Output = Relaxed

fn abs(self) -> Self::Output

impl AbsEq for Relaxed

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

👎Deprecated since 0.5.0: AbsEq will be moved in AbsOrd in v0.5

impl<R: Round, const B: Word> AbsOrd<FBig<R, B>> for Relaxed

fn abs_cmp(&self, other: &FBig<R, B>) -> Ordering

impl AbsOrd<IBig> for Relaxed

fn abs_cmp(&self, other: &IBig) -> Ordering

impl AbsOrd<RBig> for Relaxed

fn abs_cmp(&self, other: &RBig) -> Ordering

impl<R: Round, const B: Word> AbsOrd<Relaxed> for FBig<R, B>

fn abs_cmp(&self, other: &Relaxed) -> Ordering

impl AbsOrd<Relaxed> for IBig

fn abs_cmp(&self, other: &Relaxed) -> Ordering

impl AbsOrd<Relaxed> for RBig

fn abs_cmp(&self, other: &Relaxed) -> Ordering

impl AbsOrd<Relaxed> for UBig

fn abs_cmp(&self, other: &Relaxed) -> Ordering

impl AbsOrd<UBig> for Relaxed

fn abs_cmp(&self, other: &UBig) -> Ordering

impl AbsOrd for Relaxed

fn abs_cmp(&self, other: &Relaxed) -> Ordering

impl<'l, 'r> Add<&'r IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &IBig) -> Relaxed

Performs the + operation.

impl<'r> Add<&'r IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &IBig) -> Relaxed

Performs the + operation.

impl<'l, 'r> Add<&'r Relaxed> for &'l IBig

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r> Add<&'r Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r> Add<&'r Relaxed> for &'l UBig

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r> Add<&'r Relaxed> for IBig

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r> Add<&'r Relaxed> for Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r> Add<&'r Relaxed> for UBig

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r> Add<&'r UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> Relaxed

Performs the + operation.

impl<'r> Add<&'r UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> Relaxed

Performs the + operation.

impl<'l> Add<IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: IBig) -> Relaxed

Performs the + operation.

impl Add<IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: IBig) -> Relaxed

Performs the + operation.

impl<'l> Add<Relaxed> for &'l IBig

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<Relaxed> for &'l UBig

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Relaxed> for IBig

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Relaxed> for UBig

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: UBig) -> Relaxed

Performs the + operation.

impl Add<UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: UBig) -> Relaxed

Performs the + operation.

impl Add for Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&Relaxed> for Relaxed

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

Performs the += operation.

impl AddAssign for Relaxed

fn add_assign(&mut self, rhs: Relaxed)

Performs the += operation.

impl Clone for Relaxed

fn clone(&self) -> Relaxed

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Relaxed

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

Formats the value using the given formatter.

impl Default for Relaxed

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Relaxed

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for Relaxed

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

Formats the value using the given formatter.

impl Distribution<Relaxed> for Open01

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Relaxed

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl Distribution<Relaxed> for OpenClosed01

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Relaxed

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl Distribution<Relaxed> for Standard

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Relaxed

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<'a> Distribution<Relaxed> for Uniform01<'a>

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Relaxed

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<'l, 'r> Div<&'r IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: &IBig) -> Relaxed

Performs the / operation.

impl<'r> Div<&'r IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: &IBig) -> Relaxed

Performs the / operation.

impl<'l, 'r> Div<&'r Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r> Div<&'r Relaxed> for Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r> Div<&'r UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: &UBig) -> Relaxed

Performs the / operation.

impl<'r> Div<&'r UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: &UBig) -> Relaxed

Performs the / operation.

impl<'l> Div<IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: IBig) -> Relaxed

Performs the / operation.

impl Div<IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: IBig) -> Relaxed

Performs the / operation.

impl<'l> Div<Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l> Div<UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: UBig) -> Relaxed

Performs the / operation.

impl Div<UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: UBig) -> Relaxed

Performs the / operation.

impl Div for Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<&Relaxed> for Relaxed

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

Performs the /= operation.

impl DivAssign for Relaxed

fn div_assign(&mut self, rhs: Relaxed)

Performs the /= operation.

impl<'l, 'r> DivEuclid<&'r Relaxed> for &'l Relaxed

type Output = IBig

fn div_euclid(self, rhs: &Relaxed) -> IBig

impl<'r> DivEuclid<&'r Relaxed> for Relaxed

type Output = IBig

fn div_euclid(self, rhs: &Relaxed) -> IBig

impl<'l> DivEuclid<Relaxed> for &'l Relaxed

type Output = IBig

fn div_euclid(self, rhs: Relaxed) -> IBig

impl DivEuclid for Relaxed

type Output = IBig

fn div_euclid(self, rhs: Relaxed) -> IBig

impl<'l, 'r> DivRemEuclid<&'r Relaxed> for &'l Relaxed

type OutputDiv = IBig

type OutputRem = Relaxed

fn div_rem_euclid(self, rhs: &Relaxed) -> (IBig, Relaxed)

impl<'r> DivRemEuclid<&'r Relaxed> for Relaxed

type OutputDiv = IBig

type OutputRem = Relaxed

fn div_rem_euclid(self, rhs: &Relaxed) -> (IBig, Relaxed)

impl<'l> DivRemEuclid<Relaxed> for &'l Relaxed

type OutputDiv = IBig

type OutputRem = Relaxed

fn div_rem_euclid(self, rhs: Relaxed) -> (IBig, Relaxed)

impl DivRemEuclid for Relaxed

type OutputDiv = IBig

type OutputRem = Relaxed

fn div_rem_euclid(self, rhs: Relaxed) -> (IBig, Relaxed)

impl EstimatedLog2 for Relaxed

fn log2_bounds(&self) -> (f32, f32)

Estimate the bounds of the binary logarithm.

fn log2_est(&self) -> f32

Estimate the value of the binary logarithm. It’s calculated as the average of log2_bounds by default.

impl Euclid for Relaxed

fn div_euclid(&self, v: &Self) -> Self

Calculates Euclidean division, the matching method for rem_euclid.

fn rem_euclid(&self, v: &Self) -> Self

Calculates the least nonnegative remainder of self (mod v).

fn div_rem_euclid(&self, v: &Self) -> (Self, Self)

Returns both the quotient and remainder from Euclidean division.

impl From<IBig> for Relaxed

fn from(v: IBig) -> Self

Converts to this type from the input type.

impl<R: Round, const B: Word> From<Relaxed> for FBig<R, B>

fn from(v: Relaxed) -> Self

Converts to this type from the input type.

impl From<UBig> for Relaxed

fn from(v: UBig) -> Self

Converts to this type from the input type.

impl From<i128> for Relaxed

fn from(v: i128) -> Self

Converts to this type from the input type.

impl From<i16> for Relaxed

fn from(v: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Relaxed

fn from(v: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Relaxed

fn from(v: i64) -> Self

Converts to this type from the input type.

impl From<i8> for Relaxed

fn from(v: i8) -> Self

Converts to this type from the input type.

impl From<isize> for Relaxed

fn from(v: isize) -> Self

Converts to this type from the input type.

impl From<u128> for Relaxed

fn from(v: u128) -> Self

Converts to this type from the input type.

impl From<u16> for Relaxed

fn from(v: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Relaxed

fn from(v: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Relaxed

fn from(v: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Relaxed

fn from(v: u8) -> Self

Converts to this type from the input type.

impl From<usize> for Relaxed

fn from(v: usize) -> Self

Converts to this type from the input type.

impl FromPrimitive for Relaxed

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl FromStr for Relaxed

type Err = ParseError

The associated error which can be returned from parsing.

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

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

impl Inverse for &Relaxed

type Output = Relaxed

fn inv(self) -> Relaxed

impl Inverse for Relaxed

type Output = Relaxed

fn inv(self) -> Relaxed

impl<'l, 'r> Mul<&'r IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Relaxed

Performs the * operation.

impl<'r> Mul<&'r IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Relaxed

Performs the * operation.

impl<'l, 'r> Mul<&'r Relaxed> for &'l IBig

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r> Mul<&'r Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r> Mul<&'r Relaxed> for &'l UBig

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r> Mul<&'r Relaxed> for IBig

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r> Mul<&'r Relaxed> for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r> Mul<&'r Relaxed> for UBig

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r> Mul<&'r UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> Relaxed

Performs the * operation.

impl<'r> Mul<&'r UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> Relaxed

Performs the * operation.

impl<'l> Mul<IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Relaxed

Performs the * operation.

impl Mul<IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Relaxed

Performs the * operation.

impl<'l> Mul<Relaxed> for &'l IBig

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l> Mul<Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l> Mul<Relaxed> for &'l UBig

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Relaxed> for IBig

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Relaxed> for UBig

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Sign> for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: Sign) -> Self::Output

Performs the * operation.

impl<'l> Mul<UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: UBig) -> Relaxed

Performs the * operation.

impl Mul<UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: UBig) -> Relaxed

Performs the * operation.

impl Mul for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<&Relaxed> for Relaxed

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

Performs the *= operation.

impl MulAssign for Relaxed

fn mul_assign(&mut self, rhs: Relaxed)

Performs the *= operation.

impl Neg for &Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Num for Relaxed

type FromStrRadixErr = ParseError

fn from_str_radix(src: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl NumHash for Relaxed

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

Consistent Hash::hash on different numeric types.

impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for Relaxed

fn num_cmp(&self, other: &FBig<R, B>) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<IBig> for Relaxed

fn num_cmp(&self, other: &IBig) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &IBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<RBig> for Relaxed

fn num_eq(&self, other: &RBig) -> bool

PartialEq::eq on different numeric types

fn num_partial_cmp(&self, other: &RBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_cmp(&self, other: &RBig) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl<R: Round, const B: Word> NumOrd<Relaxed> for FBig<R, B>

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for IBig

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for RBig

fn num_eq(&self, other: &Relaxed) -> bool

PartialEq::eq on different numeric types

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for UBig

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for f32

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for f64

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for i128

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for i16

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for i32

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for i64

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for i8

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for isize

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for u128

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for u16

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for u32

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for u64

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for u8

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for usize

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<UBig> for Relaxed

fn num_cmp(&self, other: &UBig) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<f32> for Relaxed

fn num_cmp(&self, other: &f32) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &f32) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<f64> for Relaxed

fn num_cmp(&self, other: &f64) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &f64) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<i128> for Relaxed

fn num_cmp(&self, other: &i128) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &i128) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<i16> for Relaxed

fn num_cmp(&self, other: &i16) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &i16) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<i32> for Relaxed

fn num_cmp(&self, other: &i32) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &i32) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<i64> for Relaxed

fn num_cmp(&self, other: &i64) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &i64) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<i8> for Relaxed

fn num_cmp(&self, other: &i8) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &i8) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<isize> for Relaxed

fn num_cmp(&self, other: &isize) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &isize) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<u128> for Relaxed

fn num_cmp(&self, other: &u128) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &u128) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<u16> for Relaxed

fn num_cmp(&self, other: &u16) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &u16) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<u32> for Relaxed

fn num_cmp(&self, other: &u32) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &u32) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<u64> for Relaxed

fn num_cmp(&self, other: &u64) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &u64) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<u8> for Relaxed

fn num_cmp(&self, other: &u8) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &u8) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<usize> for Relaxed

fn num_cmp(&self, other: &usize) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &usize) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl One for Relaxed

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl Ord for Relaxed

fn cmp(&self, other: &Relaxed) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Relaxed

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Relaxed

fn partial_cmp(&self, other: &Relaxed) -> 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 Pow<usize> for &Relaxed

type Output = Relaxed

The result after applying the operator.

fn pow(self, rhs: usize) -> Relaxed

Returns self to the power rhs.

impl Pow<usize> for Relaxed

type Output = Relaxed

The result after applying the operator.

fn pow(self, rhs: usize) -> Relaxed

Returns self to the power rhs.

impl<'l, 'r> Rem<&'r Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the % operator.

fn rem(self, rhs: &Relaxed) -> Relaxed

Performs the % operation.

impl<'r> Rem<&'r Relaxed> for Relaxed

type Output = Relaxed

The resulting type after applying the % operator.

fn rem(self, rhs: &Relaxed) -> Relaxed

Performs the % operation.

impl<'l> Rem<Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the % operator.

fn rem(self, rhs: Relaxed) -> Relaxed

Performs the % operation.

impl Rem for Relaxed

type Output = Relaxed

The resulting type after applying the % operator.

fn rem(self, rhs: Relaxed) -> Relaxed

Performs the % operation.

impl RemAssign<&Relaxed> for Relaxed

fn rem_assign(&mut self, rhs: &Relaxed)

Performs the %= operation.

impl RemAssign for Relaxed

fn rem_assign(&mut self, rhs: Relaxed)

Performs the %= operation.

impl<'l, 'r> RemEuclid<&'r Relaxed> for &'l Relaxed

type Output = Relaxed

fn rem_euclid(self, rhs: &Relaxed) -> Relaxed

impl<'r> RemEuclid<&'r Relaxed> for Relaxed

type Output = Relaxed

fn rem_euclid(self, rhs: &Relaxed) -> Relaxed

impl<'l> RemEuclid<Relaxed> for &'l Relaxed

type Output = Relaxed

fn rem_euclid(self, rhs: Relaxed) -> Relaxed

impl RemEuclid for Relaxed

type Output = Relaxed

fn rem_euclid(self, rhs: Relaxed) -> Relaxed

impl Serialize for Relaxed

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Signed for Relaxed

fn sign(&self) -> Sign

fn is_positive(&self) -> bool

fn is_negative(&self) -> bool

impl Signed for Relaxed

fn abs(&self) -> Self

Computes the absolute value.

fn abs_sub(&self, other: &Self) -> Self

The positive difference of two numbers.

fn signum(&self) -> Self

Returns the sign of the number.

fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

impl<'l, 'r> Sub<&'r IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Relaxed

Performs the - operation.

impl<'r> Sub<&'r IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Relaxed

Performs the - operation.

impl<'l, 'r> Sub<&'r Relaxed> for &'l IBig

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &Relaxed) -> Relaxed

Performs the - operation.

impl<'l, 'r> Sub<&'r Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &Relaxed) -> Relaxed

Performs the - operation.

impl<'l, 'r> Sub<&'r Relaxed> for &'l UBig

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &Relaxed) -> Relaxed

Performs the - operation.

impl<'r> Sub<&'r Relaxed> for IBig

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &Relaxed) -> Relaxed

Performs the - operation.

impl<'r> Sub<&'r Relaxed> for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &Relaxed) -> Relaxed

Performs the - operation.

impl<'r> Sub<&'r Relaxed> for UBig

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &Relaxed) -> Relaxed

Performs the - operation.

impl<'l, 'r> Sub<&'r UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> Relaxed

Performs the - operation.

impl<'r> Sub<&'r UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> Relaxed

Performs the - operation.

impl<'l> Sub<IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Relaxed

Performs the - operation.

impl Sub<IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Relaxed

Performs the - operation.

impl<'l> Sub<Relaxed> for &'l IBig

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: Relaxed) -> Relaxed

Performs the - operation.

impl<'l> Sub<Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: Relaxed) -> Relaxed

Performs the - operation.

impl<'l> Sub<Relaxed> for &'l UBig

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: Relaxed) -> Relaxed

Performs the - operation.

impl Sub<Relaxed> for IBig

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: Relaxed) -> Relaxed

Performs the - operation.

impl Sub<Relaxed> for UBig

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: Relaxed) -> Relaxed

Performs the - operation.

impl<'l> Sub<UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: UBig) -> Relaxed

Performs the - operation.

impl Sub<UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: UBig) -> Relaxed

Performs the - operation.

impl Sub for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: Relaxed) -> Relaxed

Performs the - operation.

impl SubAssign<&Relaxed> for Relaxed

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

Performs the -= operation.

impl SubAssign for Relaxed

fn sub_assign(&mut self, rhs: Relaxed)

Performs the -= operation.

impl ToPrimitive for Relaxed

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

impl<R: Round, const B: Word> TryFrom<FBig<R, B>> for Relaxed

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: FBig<R, B>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for IBig

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for UBig

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for f32

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for f64

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for i128

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for i16

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for i32

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for i64

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for i8

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for isize

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for u128

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for u16

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for u32

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for u64

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for u8

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Relaxed> for usize

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<Self, Self::Error>

Performs the conversion.

impl<const B: Word> TryFrom<Repr<B>> for Relaxed

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: FBigRepr<B>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<f32> for Relaxed

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: f32) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<f64> for Relaxed

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: f64) -> Result<Self, Self::Error>

Performs the conversion.

impl Zero for Relaxed

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Zeroize for Relaxed

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl Eq for Relaxed

impl StructuralPartialEq for Relaxed