Struct RBig 

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

An arbitrary precision rational number.

This struct represents an rational number with arbitrarily large numerator and denominator based on UBig and IBig.

Implementations

impl RBig

pub fn to_f32_fast(&self) -> f32

Convert the rational number to a f32.

The rounding follows the default IEEE 754 behavior (rounds to nearest, ties to even).

The rounding will be correct at most of the time, but in rare cases the mantissa can be off by one bit. Use RBig::to_f32 for ensured correct rounding.

Examples

assert_eq!(RBig::ONE.to_f32_fast(), 1f32);

let r = RBig::from_parts(22.into(), 7u8.into());
assert_eq!(r.to_f32_fast(), 22./7.)

pub fn to_f64_fast(&self) -> f64

Convert the rational number to a f64.

The rounding follows the default IEEE 754 behavior (rounds to nearest, ties to even).

The rounding will be correct at most of the time, but in rare cases the mantissa can be off by one bit. Use RBig::to_f64 for ensured correct rounding.

Examples

assert_eq!(RBig::ONE.to_f64_fast(), 1f64);

let r = RBig::from_parts(22.into(), 7u8.into());
assert_eq!(r.to_f64_fast(), 22./7.)

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

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

The rounding follows the default IEEE 754 behavior (rounds to nearest, ties to even).

Because of the guaranteed rounding, it might take a long time to convert when the numerator and denominator are large. In this case RBig::to_f32_fast can be used if the correct rounding is not required.

Examples

assert_eq!(RBig::ONE.to_f32(), Exact(1f32));

let r = RBig::from_parts(22.into(), 7u8.into());
// f32 representation of 22/7 is smaller than the actual 22/7
assert_eq!(r.to_f32(), Inexact(22./7., Negative));

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

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

The rounding follows the default IEEE 754 behavior (rounds to nearest, ties to even).

Because of the guaranteed rounding, it might take a long time to convert when the numerator and denominator are large. In this case RBig::to_f64_fast can be used if the correct rounding is not required.

Examples

assert_eq!(RBig::ONE.to_f64(), Exact(1f64));

let r = RBig::from_parts(22.into(), 7u8.into());
// f64 representation of 22/7 is smaller than the actual 22/7
assert_eq!(r.to_f64(), Inexact(22./7., Negative));

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

Convert the rational number to an IBig.

The conversion rounds toward zero. It’s equivalent to RBig::trunc, but it returns the fractional part if the rational number is not an integer.

Examples

let a = RBig::from_parts(22.into(), UBig::ONE);
assert_eq!(a.to_int(), Exact(IBig::from(22)));

let b = RBig::from_parts(22.into(), 7u8.into());
assert_eq!(b.to_int(), Inexact(
    IBig::from(3), RBig::from_parts(1.into(), 7u8.into())
));

impl RBig

pub fn sqr(&self) -> RBig

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

Examples

let a = RBig::from_parts(2.into(), 3u8.into());
let a2 = RBig::from_parts(4.into(), 9u8.into());
assert_eq!(a.sqr(), a2);

pub fn cubic(&self) -> RBig

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

Examples

let a = RBig::from_parts(2.into(), 3u8.into());
let a3 = RBig::from_parts(8.into(), 27u8.into());
assert_eq!(a.cubic(), a3);

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

Raise this number to a power of n.

Examples

let a = RBig::from_parts(2.into(), 3u8.into());
let a5 = RBig::from_parts(32.into(), 243u8.into());
assert_eq!(a.pow(5), a5);

impl RBig

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

Convert a string in a given base to RBig.

The numerator and the denominator are separated by /. src may contain an optional + prefix. Digits 10-35 are represented by a-z or A-Z.

Examples

assert_eq!(
    RBig::from_str_radix("+7ab/-sse", 32)?,
    RBig::from_parts((-7499).into(), 29582u16.into())
);

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

Convert a string with optional radix prefixes to RBig, return the parsed integer and radix. If no prefix is present, then the default radix 10 will be used for parsing.

src may contain an ‘+’ or - prefix before the radix prefix of both the numerator and denominator.

Allowed prefixes: 0b for binary, 0o for octal, 0x for hexadecimal.

If the radix prefixes for the numerator and the denominator are not the same, then a ParseError will be returned. The radix prefix for the denominator can be omitted, and the radix for the numerator will used for parsing.

Examples

assert_eq!(RBig::from_str_with_radix_prefix("+0o17/25")?,
    (RBig::from_parts(0o17.into(), 0o25u8.into()), 8));
assert_eq!(RBig::from_str_with_radix_prefix("-0x1f/-0x1e")?,
    (RBig::from_parts(0x1f.into(), 0x1eu8.into()), 16));

impl RBig

pub const ZERO: RBig

RBig with value 0

pub const ONE: RBig

RBig with value 1

pub const NEG_ONE: RBig

RBig with value -1

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

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

Examples

assert_eq!(RBig::from_parts(IBig::ZERO, UBig::ONE), RBig::ZERO);
assert_eq!(RBig::from_parts(IBig::ONE, UBig::ONE), RBig::ONE);
assert_eq!(RBig::from_parts(IBig::NEG_ONE, UBig::ONE), RBig::NEG_ONE);

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

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

Examples

assert_eq!(RBig::ZERO.into_parts(), (IBig::ZERO, UBig::ONE));
assert_eq!(RBig::ONE.into_parts(), (IBig::ONE, UBig::ONE));
assert_eq!(RBig::NEG_ONE.into_parts(), (IBig::NEG_ONE, UBig::ONE));

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

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

Examples

assert_eq!(RBig::from_parts_signed(1.into(), 1.into()), RBig::ONE);
assert_eq!(RBig::from_parts_signed(12.into(), (-12).into()), RBig::NEG_ONE);

pub const fn from_parts_const( sign: Sign, numerator: u128, denominator: u128, ) -> RBig

Create a rational number in a const context

The magnitude of the numerator and the denominator is limited to a DoubleWord.

Examples

const ONE: RBig = RBig::from_parts_const(Sign::Positive, 1, 1);
assert_eq!(ONE, RBig::ONE);
const NEG_ONE: RBig = RBig::from_parts_const(Sign::Negative, 1, 1);
assert_eq!(NEG_ONE, RBig::NEG_ONE);

pub fn numerator(&self) -> &IBig

Get the numerator of the rational number

Examples

assert_eq!(RBig::ZERO.numerator(), &IBig::ZERO);
assert_eq!(RBig::ONE.numerator(), &IBig::ONE);

pub fn denominator(&self) -> &UBig

Get the denominator of the rational number

Examples

assert_eq!(RBig::ZERO.denominator(), &UBig::ONE);
assert_eq!(RBig::ONE.denominator(), &UBig::ONE);

pub fn relax(self) -> Relaxed

Convert this rational number into a Relaxed version

Examples

assert_eq!(RBig::ZERO.relax(), Relaxed::ZERO);
assert_eq!(RBig::ONE.relax(), Relaxed::ONE);

pub const fn as_relaxed(&self) -> &Relaxed

Regard the number as a Relaxed number and return a reference of Relaxed type.

Examples

assert_eq!(RBig::ONE.as_relaxed(), &Relaxed::ONE);

pub const fn is_zero(&self) -> bool

Check whether the number is 0

Examples

assert!(RBig::ZERO.is_zero());
assert!(!RBig::ONE.is_zero());

pub const fn is_one(&self) -> bool

Check whether the number is 1

Examples

assert!(!RBig::ZERO.is_one());
assert!(RBig::ONE.is_one());

pub const fn is_int(&self) -> bool

Determine if the number can be regarded as an integer.

Examples

assert!(RBig::ZERO.is_int());
assert!(RBig::ONE.is_int());

impl RBig

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

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

It’s return is equivalent to (self.trunc(), self.fract())

Examples

assert_eq!(RBig::ONE.split_at_point(), (IBig::ONE, RBig::ZERO));

let a = RBig::from_parts(22.into(), 7u8.into());
let (trunc, fract) = a.split_at_point();
assert_eq!(trunc, IBig::from(3));
assert_eq!(fract, RBig::from_parts(1.into(), 7u8.into()));

pub fn ceil(&self) -> IBig

Compute the least integer that is greater than or equal to this number.

Examples

assert_eq!(RBig::ONE.ceil(), IBig::ONE);

let a = RBig::from_parts(22.into(), 7u8.into());
assert_eq!(a.ceil(), IBig::from(4));

pub fn floor(&self) -> IBig

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

Examples

assert_eq!(RBig::ONE.floor(), IBig::ONE);

let a = RBig::from_parts(22.into(), 7u8.into());
assert_eq!(a.floor(), IBig::from(3));

pub fn round(&self) -> IBig

Compute the integer that closest to this number.

It will return the one farther from zero when the number has the 1/2 as its fractional part.

Examples

assert_eq!(RBig::ONE.round(), IBig::ONE);

let a = RBig::from_parts(22.into(), 7u8.into());
assert_eq!(a.round(), IBig::from(3));

pub fn trunc(&self) -> IBig

Returns the integral part of the rational number.

It’s guaranteed that self == self.trunc() + self.fract().

Examples

assert_eq!(RBig::ONE.trunc(), IBig::ONE);

let a = RBig::from_parts(22.into(), 7u8.into());
assert_eq!(a.trunc(), IBig::from(3));

pub fn fract(&self) -> RBig

Returns the fractional part of the rational number

It’s guaranteed that self == self.trunc() + self.fract().

Examples

assert_eq!(RBig::ONE.fract(), RBig::ZERO);

let a = RBig::from_parts(22.into(), 7u8.into());
assert_eq!(a.fract(), RBig::from_parts(1.into(), 7u8.into()));

impl RBig

pub const fn sign(&self) -> Sign

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

Examples

assert_eq!(RBig::ZERO.sign(), Sign::Positive);
assert_eq!(RBig::ONE.sign(), Sign::Positive);
assert_eq!(RBig::NEG_ONE.sign(), Sign::Negative);

pub const fn signum(&self) -> RBig

A number representing the sign of self.

• RBig::ONE if the number is positive (including inf)
• RBig::ZERO if the number is zero
• RBig::NEG_ONE if the number is negative (including -inf)

Examples

let r = RBig::from_parts((-10).into(), 5u8.into());
assert_eq!(r.signum(), RBig::NEG_ONE);

impl RBig

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

Determine if this rational number is simpler than the other number.

This method only make sense for canonicalized ratios.

pub fn simplest_from_f32(f: f32) -> Option<RBig>

Find the simplest rational number in the rounding interval of the f32 number.

This method returns None when the floating point value is not representable by a rational number, such as infinities or nans.

See RBig::simplest_in for the definition of simplicity.

The rounding interval of a f32 value is an interval such that all numbers in this range will rounded to this f32 value. For example the rounding interval for 1f32 is [1. - f32::EPSILON / 2, 1. + f32::EPSILON / 2]. That is, the error of result value will be less than 1/2 ULP.

This method can be used to recover the original fraction represented as a division of f32. See the examples below.

Examples

assert_eq!(
    RBig::simplest_from_f32(1e-1).unwrap(),
    RBig::from_parts(1.into(), 10u8.into())
);
assert_eq!(
    RBig::simplest_from_f32(22./7.).unwrap(),
    RBig::from_parts(22.into(), 7u8.into())
);

pub fn simplest_from_f64(f: f64) -> Option<RBig>

Find the simplest rational number in the rounding interval of the f64 number.

This method returns None when the floating point value is not representable by a rational number, such as infinities or nans.

See RBig::simplest_in for the definition of simplicity.

The rounding interval of a f64 value is an interval such that all numbers in this range will rounded to this f64 value. For example the rounding interval for 1f64 is [1. - f64::EPSILON / 2, 1. + f64::EPSILON / 2]. That is, the error of result value will be less than 1/2 ULP.

This method can be used to recover the original fraction represented as a division of f64. See the examples below.

Examples

assert_eq!(
    RBig::simplest_from_f64(1e-1).unwrap(),
    RBig::from_parts(1.into(), 10u8.into())
);
assert_eq!(
    RBig::simplest_from_f64(22./7.).unwrap(),
    RBig::from_parts(22.into(), 7u8.into())
);

pub fn simplest_in(lower: RBig, upper: RBig) -> RBig

Find the simplest rational number in the open interval (lower, upper).

A rational n₁/d₁ is simpler than another rational number n₂/d₂ if:

• d₁ < d₂ (compare denominator)
• or |n₁| < |n₂| (then compare the magnitude of numerator)
• or n₂ < 0 < n₁ (then compare the sign)

lower and upper will be swapped if necessary. If lower and upper are the same number, then this number will be directly returned.

Examples

let a = RBig::from_parts(1234.into(), 5678u16.into());
let b = RBig::from_parts(1235.into(), 5679u16.into());
let s = RBig::simplest_in(a, b);
// 1234/5678 < 5/23 < 1235/5679
assert_eq!(s, RBig::from_parts(5.into(), 23u8.into()));

pub fn nearest(&self, limit: &UBig) -> Approximation<RBig, Sign>

Find the closest rational number to this number with a limit of the denominator.

If the denominator of this number is larger than the limit, then it returns the closest one between self.next_up() and self.next_down() to self. If the denominator of this number is already less than or equal to the limit, then Exact(self) will be returned.

The error |self - self.nearest()| will be less than 1/(2*limit), and the sign of the error self - self.nearest() will be returned if the result is not Exact.

Examples

let a: RBig = 3.141592653.try_into().unwrap();
assert_eq!(a.nearest(&10u8.into()), Inexact(
    RBig::from_parts(22.into(), 7u8.into()),
    Sign::Positive // 22/7 > 3.141592653
));

pub fn next_up(&self, limit: &UBig) -> RBig

Find the closest rational number that is greater than this number and has a denominator less than limit.

It’s equivalent to finding the next element in Farey sequence of order limit. The error |self - self.next_up()| will be less than 1/limit.

Examples

let a: RBig = 3.141592653.try_into().unwrap();
assert_eq!(a.next_up(&10u8.into()), RBig::from_parts(22.into(), 7u8.into()));

pub fn next_down(&self, limit: &UBig) -> RBig

Find the closest rational number that is less than this number and has a denominator less than limit.

It’s equivalent to finding the previous element in Farey sequence of order limit. The error |self - self.next_down()| will be less than 1/limit.

Examples

let a: RBig = 3.141592653.try_into().unwrap();
assert_eq!(a.next_down(&10u8.into()), RBig::from_parts(25.into(), 8u8.into()));

impl RBig

pub fn to_float<R, const B: u64>( &self, precision: usize, ) -> Approximation<FBig<R, B>, Rounding>

where R: Round,

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

Examples

use dashu_float::{DBig, round::Rounding::*};

assert_eq!(RBig::ONE.to_float(1), Exact(DBig::ONE));
assert_eq!(RBig::from(1000).to_float(4), Exact(DBig::from(1000)));
assert_eq!(RBig::from_parts(1000.into(), 6u8.into()).to_float(4),
    Inexact(DBig::from_parts(1667.into(), -1), AddOne));

pub fn simplest_from_float<R, const B: u64>(f: &FBig<R, B>) -> Option<RBig>

where R: ErrorBounds,

Examples

use dashu_float::DBig;

let f = DBig::from_str_native("4.00")? / DBig::from_str_native("3.00")?;
let r = RBig::from_str_radix("4/3", 10)?;
assert_eq!(RBig::simplest_from_float(&f), Some(r));
assert_eq!(RBig::simplest_from_float(&DBig::INFINITY), None);

Trait Implementations

impl Abs for RBig

type Output = RBig

fn abs(self) -> <RBig as Abs>::Output

impl AbsEq for RBig

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

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

impl<R, const B: u64> AbsOrd<FBig<R, B>> for RBig

where R: Round,

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

impl AbsOrd<IBig> for RBig

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

impl<R, const B: u64> AbsOrd<RBig> for FBig<R, B>

where R: Round,

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

impl AbsOrd<RBig> for IBig

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

impl AbsOrd<RBig> for Relaxed

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

impl AbsOrd<RBig> for UBig

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

impl AbsOrd<Relaxed> for RBig

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

impl AbsOrd<UBig> for RBig

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

impl AbsOrd for RBig

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

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for RBig

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<RBig> for IBig

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<RBig> for UBig

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for RBig

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for RBig

type Output = RBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&RBig> for RBig

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

Performs the += operation.

impl AddAssign for RBig

fn add_assign(&mut self, rhs: RBig)

Performs the += operation.

impl Clone for RBig

fn clone(&self) -> RBig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RBig

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

Formats the value using the given formatter.

impl Default for RBig

fn default() -> RBig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RBig

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for RBig

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

Formats the value using the given formatter.

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

fn sample<R>(&self, rng: &mut R) -> RBig

where R: Rng + ?Sized,

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 RBig

type Output = RBig

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = RBig

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = RBig

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = RBig

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = RBig

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = RBig

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = RBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<IBig> for RBig

type Output = RBig

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = RBig

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = RBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<UBig> for RBig

type Output = RBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for RBig

type Output = RBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<&RBig> for RBig

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

Performs the /= operation.

impl DivAssign for RBig

fn div_assign(&mut self, rhs: RBig)

Performs the /= operation.

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

type Output = IBig

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

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

type Output = IBig

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

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

type Output = IBig

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

impl DivEuclid for RBig

type Output = IBig

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

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

type OutputDiv = IBig

type OutputRem = RBig

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

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

type OutputDiv = IBig

type OutputRem = RBig

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

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

type OutputDiv = IBig

type OutputRem = RBig

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

impl DivRemEuclid for RBig

type OutputDiv = IBig

type OutputRem = RBig

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

impl EstimatedLog2 for RBig

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 RBig

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

Calculates Euclidean division, the matching method for rem_euclid.

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

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 RBig

fn from(v: IBig) -> RBig

Converts to this type from the input type.

impl<R, const B: u64> From<RBig> for FBig<R, B>

where R: Round,

fn from(v: RBig) -> FBig<R, B>

Converts to this type from the input type.

impl From<UBig> for RBig

fn from(v: UBig) -> RBig

Converts to this type from the input type.

impl From<i128> for RBig

fn from(v: i128) -> RBig

Converts to this type from the input type.

impl From<i16> for RBig

fn from(v: i16) -> RBig

Converts to this type from the input type.

impl From<i32> for RBig

fn from(v: i32) -> RBig

Converts to this type from the input type.

impl From<i64> for RBig

fn from(v: i64) -> RBig

Converts to this type from the input type.

impl From<i8> for RBig

fn from(v: i8) -> RBig

Converts to this type from the input type.

impl From<isize> for RBig

fn from(v: isize) -> RBig

Converts to this type from the input type.

impl From<u128> for RBig

fn from(v: u128) -> RBig

Converts to this type from the input type.

impl From<u16> for RBig

fn from(v: u16) -> RBig

Converts to this type from the input type.

impl From<u32> for RBig

fn from(v: u32) -> RBig

Converts to this type from the input type.

impl From<u64> for RBig

fn from(v: u64) -> RBig

Converts to this type from the input type.

impl From<u8> for RBig

fn from(v: u8) -> RBig

Converts to this type from the input type.

impl From<usize> for RBig

fn from(v: usize) -> RBig

Converts to this type from the input type.

impl FromPrimitive for RBig

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

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<RBig>

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<RBig>

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<RBig>

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<RBig>

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<RBig>

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<RBig>

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<RBig>

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<RBig>

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<RBig>

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<RBig>

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<RBig>

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<RBig>

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<RBig>

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 RBig

type Err = ParseError

The associated error which can be returned from parsing.

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

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

impl Hash for RBig

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

where H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Inverse for &RBig

type Output = RBig

fn inv(self) -> RBig

impl Inverse for RBig

type Output = RBig

fn inv(self) -> RBig

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<IBig> for RBig

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<RBig> for IBig

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<RBig> for UBig

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Sign> for RBig

type Output = RBig

The resulting type after applying the * operator.

fn mul(self, rhs: Sign) -> RBig

Performs the * operation.

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

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for RBig

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for RBig

type Output = RBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<&RBig> for RBig

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

Performs the *= operation.

impl MulAssign for RBig

fn mul_assign(&mut self, rhs: RBig)

Performs the *= operation.

impl Neg for &RBig

type Output = RBig

The resulting type after applying the - operator.

fn neg(self) -> <&RBig as Neg>::Output

Performs the unary - operation.

impl Neg for RBig

type Output = RBig

The resulting type after applying the - operator.

fn neg(self) -> <RBig as Neg>::Output

Performs the unary - operation.

impl Num for RBig

type FromStrRadixErr = ParseError

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

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

impl NumHash for RBig

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

where H: Hasher,

Consistent Hash::hash on different numeric types.

impl<R, const B: u64> NumOrd<FBig<R, B>> for RBig

where R: Round,

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 RBig

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<R, const B: u64> NumOrd<RBig> for FBig<R, B>

where R: Round,

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_partial_cmp(&self, other: &RBig) -> 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 IBig

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_partial_cmp(&self, other: &RBig) -> 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 NumOrd<RBig> for UBig

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_partial_cmp(&self, other: &RBig) -> 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<UBig> for RBig

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 RBig

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 RBig

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 RBig

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 RBig

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 RBig

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 RBig

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 RBig

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 RBig

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 RBig

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 RBig

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 RBig

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 RBig

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 RBig

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 RBig

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 RBig

fn one() -> RBig

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 RBig

fn cmp(&self, other: &RBig) -> 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 RBig

fn eq(&self, other: &RBig) -> 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 RBig

fn partial_cmp(&self, other: &RBig) -> 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 &RBig

type Output = RBig

The result after applying the operator.

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

Returns self to the power rhs.

impl Pow<usize> for RBig

type Output = RBig

The result after applying the operator.

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

Returns self to the power rhs.

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

type Output = RBig

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = RBig

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = RBig

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem for RBig

type Output = RBig

The resulting type after applying the % operator.

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

Performs the % operation.

impl RemAssign<&RBig> for RBig

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

Performs the %= operation.

impl RemAssign for RBig

fn rem_assign(&mut self, rhs: RBig)

Performs the %= operation.

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

type Output = RBig

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

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

type Output = RBig

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

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

type Output = RBig

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

impl RemEuclid for RBig

type Output = RBig

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

impl SampleUniform for RBig

type Sampler = UniformRBig

The UniformSampler implementation supporting type X.

impl Serialize for RBig

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Signed for RBig

fn sign(&self) -> Sign

fn is_positive(&self) -> bool

fn is_negative(&self) -> bool

impl Signed for RBig

fn abs(&self) -> RBig

Computes the absolute value.

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

The positive difference of two numbers.

fn signum(&self) -> RBig

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 RBig

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<IBig> for RBig

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<RBig> for IBig

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<RBig> for UBig

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<UBig> for RBig

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for RBig

type Output = RBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<&RBig> for RBig

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

Performs the -= operation.

impl SubAssign for RBig

fn sub_assign(&mut self, rhs: RBig)

Performs the -= operation.

impl ToPrimitive for RBig

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, const B: u64> TryFrom<FBig<R, B>> for RBig

where R: Round,

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from( value: FBig<R, B>, ) -> Result<RBig, <RBig as TryFrom<FBig<R, B>>>::Error>

Performs the conversion.

impl TryFrom<RBig> for IBig

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: RBig) -> Result<IBig, <IBig as TryFrom<RBig>>::Error>

Performs the conversion.

impl TryFrom<RBig> for UBig

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: RBig) -> Result<UBig, <UBig as TryFrom<RBig>>::Error>

Performs the conversion.

impl<const B: u64> TryFrom<Repr<B>> for RBig

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Repr<B>) -> Result<RBig, <RBig as TryFrom<Repr<B>>>::Error>

Performs the conversion.

impl TryFrom<f32> for RBig

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: f32) -> Result<RBig, <RBig as TryFrom<f32>>::Error>

Performs the conversion.

impl TryFrom<f64> for RBig

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: f64) -> Result<RBig, <RBig as TryFrom<f64>>::Error>

Performs the conversion.

impl Zero for RBig

fn zero() -> RBig

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 RBig

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 RBig