Struct FBig 

pub struct FBig<RoundingMode: Round = Zero, const BASE: Word = 2> { /* private fields */ }

An arbitrary precision floating point number with arbitrary base and rounding mode.

An FBig is a Repr (the value: significand × base^exponent) paired with a Context (the precision cap and rounding mode). Arithmetic follows the associated context; use the Context methods directly when you need a different precision/rounding, or to receive the rounding direction and errors instead of a panic.

The generic parameters are BASE (B, in [2, isize::MAX]) and RoundingMode (R, chosen from the mode module). With the defaults the number is base 2 rounded towards zero (the most efficient format); DBig aliases base 10 rounded to nearest.

Binary operators require both operands to share the same base and rounding mode (no hidden conversion is performed); comparison allows differing rounding modes but not differing bases.

See the user guide for the memory layout, and the construction, parsing & printing, IEEE 754 compliance, and conversion pages for those topics. (Notably: FBig has no NaN, supports IEEE-754 signed zero, and treats infinities as terminal values.) The accepted string format is documented on the core::str::FromStr impl.

Examples

use core::str::FromStr;

// parsing
let a = DBig::from_parts(123456789.into(), -5);
let b = DBig::from_str("1234.56789")?;
let c = DBig::from_str("1.23456789e3")?;
assert_eq!(a, b);
assert_eq!(b, c);

// printing
assert_eq!(format!("{}", DBig::from_str("12.34")?), "12.34");
let x = DBig::from_str("10.01")?
    .with_precision(0) // use unlimited precision
    .value();
if dashu_int::Word::BITS == 64 {
    // number of digits to display depends on the word size
    assert_eq!(
        format!("{:?}", x.powi(100.into())),
        "1105115697720767968..1441386704950100001 * 10 ^ -200 (prec: 0)"
    );
}

Implementations

impl<R: Round, const B: Word> FBig<R, B>

pub fn to_decimal(&self) -> Rounded<FBig<HalfAway, 10>>

Convert the float number to base 10 (with decimal exponents) rounding to even and tying away from zero.

It’s equivalent to self.with_rounding::<HalfAway>().with_base::<10>(). The output is directly of type DBig.

See with_base() for the precision behavior.

Examples

use dashu_base::Approximation::*;
use dashu_float::round::Rounding::*;

type Real = FBig;

assert_eq!(
    Real::from_str("0x1234")?.to_decimal(),
    Exact(DBig::from_str("4660")?)
);
assert_eq!(
    Real::from_str("0x12.34")?.to_decimal(),
    Inexact(DBig::from_str("18.20")?, NoOp)
);
assert_eq!(
    Real::from_str("0x1.234p-4")?.to_decimal(),
    Inexact(DBig::from_str("0.07111")?, AddOne)
);

Panics

Panics if the associated context has unlimited precision and the conversion cannot be performed losslessly.

pub fn to_binary(&self) -> Rounded<FBig<Zero, 2>>

Convert the float number to base 2 (with binary exponents) rounding towards zero.

It’s equivalent to self.with_rounding::<Zero>().with_base::<2>().

See with_base() for the precision and rounding behavior.

Examples

use dashu_base::Approximation::*;
use dashu_float::round::{mode::HalfAway, Rounding::*};

type Real = FBig;

assert_eq!(
    DBig::from_str("1234")?.to_binary(),
    Exact(Real::from_str("0x4d2")?)
);
assert_eq!(
    DBig::from_str("12.34")?.to_binary(),
    Inexact(Real::from_str("0xc.57")?, NoOp)
);
assert_eq!(
    DBig::from_str("1.234e-1")?.to_binary(),
    Inexact(Real::from_str("0x1.f97p-4")?, NoOp)
);

Panics

Panics if the associated context has unlimited precision and the conversion cannot be performed losslessly.

pub fn with_precision(self, precision: usize) -> Rounded<Self>

Explicitly change the precision of the float number.

If the given precision is less than the current value in the context, it will be rounded with the rounding mode specified by the generic parameter.

Examples

use dashu_base::Approximation::*;
use dashu_float::round::{mode::HalfAway, Rounding::*};

let a = DBig::from_str("2.345")?;
assert_eq!(a.precision(), 4);
assert_eq!(
    a.clone().with_precision(3),
    Inexact(DBig::from_str("2.35")?, AddOne)
);
assert_eq!(
    a.clone().with_precision(5),
    Exact(DBig::from_str("2.345")?)
);

pub fn with_rounding<NewR: Round>(self) -> FBig<NewR, B>

Explicitly change the rounding mode of the number.

This operation doesn’t modify the underlying representation, it only changes the rounding mode in the context.

Examples

use dashu_base::Approximation::*;
use dashu_float::round::{mode::{HalfAway, Zero}, Rounding::*};

type DBigHalfAway = DBig;
type DBigZero = FBig::<Zero, 10>;

let a = DBigHalfAway::from_str("2.345")?;
let b = DBigZero::from_str("2.345")?;
assert_eq!(a.with_rounding::<Zero>(), b);

pub fn with_base<const NewB: Word>(self) -> Rounded<FBig<R, NewB>>

Explicitly change the base of the float number.

This function internally calls with_base_and_precision. The precision of the result number will be calculated in such a way that the new limit of the significand is less than or equal to before. That is, the new precision will be the max integer such that

NewB ^ new_precision <= B ^ old_precision

If any rounding happens during the conversion, it follows the rounding mode specified by the generic parameter.

Examples

use dashu_base::Approximation::*;
use dashu_float::round::{mode::Zero, Rounding::*};

type FBin = FBig;
type FDec = FBig<Zero, 10>;
type FHex = FBig<Zero, 16>;

let a = FBin::from_str("0x1.234")?; // 0x1234 * 2^-12
assert_eq!(
    a.clone().with_base::<10>(),
    // 1.1376953125 rounded towards zero
    Inexact(FDec::from_str("1.137")?, NoOp)
);
assert_eq!(
    a.clone().with_base::<16>(),
    // conversion is exact when the new base is a power of the old base
    Exact(FHex::from_str("1.234")?)
);

Panics

Panics if the associated context has unlimited precision and the conversion cannot be performed losslessly.

pub fn with_base_and_precision<const NewB: Word>( self, precision: usize, ) -> Rounded<FBig<R, NewB>>

Explicitly change the base of the float number with given precision (under the new base).

Infinities are mapped to infinities inexactly, the error will be NoOp.

Conversion for float numbers with unlimited precision is only allowed in following cases:

• The number is infinite
• The new base NewB is a power of B
• B is a power of the new base NewB

Examples

use dashu_base::Approximation::*;
use dashu_float::round::{mode::Zero, Rounding::*};

type FBin = FBig;
type FDec = FBig<Zero, 10>;
type FHex = FBig<Zero, 16>;

let a = FBin::from_str("0x1.234")?; // 0x1234 * 2^-12
assert_eq!(
    a.clone().with_base_and_precision::<10>(8),
    // 1.1376953125 rounded towards zero
    Inexact(FDec::from_str("1.1376953")?, NoOp)
);
assert_eq!(
    a.clone().with_base_and_precision::<16>(8),
    // conversion can be exact when the new base is a power of the old base
    Exact(FHex::from_str("1.234")?)
);
assert_eq!(
    a.clone().with_base_and_precision::<16>(2),
    // but the conversion is still inexact if the target precision is smaller
    Inexact(FHex::from_str("1.2")?, NoOp)
);

Panics

Panics if the associated context has unlimited precision and the conversion cannot be performed losslessly.

pub fn to_int(&self) -> Rounded<IBig>

Convert the float number to integer with the given rounding mode.

Warning

If the float number has a very large exponent, it will be evaluated and result in allocating an huge integer and it might eat up all your memory.

To get a rough idea of how big the number is, it’s recommended to use EstimatedLog2.

Examples

use dashu_base::Approximation::*;
use dashu_float::round::Rounding::*;

assert_eq!(
    DBig::from_str("1234")?.to_int(),
    Exact(1234.into())
);
assert_eq!(
    DBig::from_str("1.234e6")?.to_int(),
    Exact(1234000.into())
);
assert_eq!(
    DBig::from_str("1.234")?.to_int(),
    Inexact(1.into(), NoOp)
);

Panics

Panics if the number is infinte

pub fn to_f32(&self) -> Rounded<f32>

Convert the float number to f32 with the rounding mode associated with the type.

Note that the conversion is inexact even if the number is infinite.

Examples

assert_eq!(DBig::from_str("1.234")?.to_f32().value(), 1.234);
assert_eq!(DBig::INFINITY.to_f32().value(), f32::INFINITY);

pub fn to_f64(&self) -> Rounded<f64>

Convert the float number to f64 with the rounding mode associated with the type.

Note that the conversion is inexact even if the number is infinite.

Examples

assert_eq!(DBig::from_str("1.234")?.to_f64().value(), 1.234);
assert_eq!(DBig::INFINITY.to_f64().value(), f64::INFINITY);

impl<R: Round, const B: Word> FBig<R, B>

pub fn inv(&self) -> Self

Calculate the multiplicative inverse (1 / self) of the floating point number.

Panics

Panics if the precision is unlimited.

impl<R: Round, const B: Word> FBig<R, B>

pub fn powi(&self, exp: IBig) -> FBig<R, B>

Raise the floating point number to an integer power.

Examples

let a = DBig::from_str("-1.234")?;
assert_eq!(a.powi(10.into()), DBig::from_str("8.188")?);

pub fn powf(&self, exp: &Self) -> Self

Raise the floating point number to an floating point power.

Examples

let x = DBig::from_str("1.23")?;
let y = DBig::from_str("-4.56")?;
assert_eq!(x.powf(&y), DBig::from_str("0.389")?);

pub fn exp(&self) -> FBig<R, B>

Calculate the exponential function (eˣ) on the floating point number.

Examples

let a = DBig::from_str("-1.234")?;
assert_eq!(a.exp(), DBig::from_str("0.2911")?);

pub fn exp_m1(&self) -> FBig<R, B>

Calculate the exponential minus one function (eˣ-1) on the floating point number.

Examples

let a = DBig::from_str("-0.1234")?;
assert_eq!(a.exp_m1(), DBig::from_str("-0.11609")?);

impl<R: Round, const B: Word> FBig<R, B>

pub const ZERO: Self

FBig with value 0 and unlimited precision

To test if the float number is +0, use self.repr().is_pos_zero() (or self.repr().significand().is_zero() to detect either signed zero).

pub const ONE: Self

FBig with value 1 and unlimited precision

To test if the float number is one, use self.repr().is_one().

pub const NEG_ONE: Self

FBig with value -1 and unlimited precision

pub const INFINITY: Self

FBig instance representing the positive infinity (+∞)

To test if the float number is infinite, use self.repr().infinite().

pub const NEG_INFINITY: Self

FBig instance representing the negative infinity (-∞)

To test if the float number is infinite, use self.repr().infinite().

pub fn from_repr(repr: Repr<B>, context: Context<R>) -> Self

Create a FBig instance from Repr and Context.

This method should not be used in most cases. It’s designed to be used when you hold a Repr instance and want to create an FBig from that.

Examples

use dashu_float::{Repr, Context};

assert_eq!(DBig::from_repr(Repr::one(), Context::new(1)), DBig::ONE);
assert_eq!(DBig::from_repr(Repr::infinity(), Context::new(1)), DBig::INFINITY);

Panics

Panics if the Repr has more digits than precision + 1 (the one allowed guard digit from an inexact add/sub — see Repr). Note that this condition is not checked in release builds.

pub const fn from_repr_const(repr: Repr<B>) -> Self

Create a FBig instance from Repr. Due to the limitation of const operations, the precision of the float is set to unlimited.

Examples

use dashu_float::{Repr, Context};

assert_eq!(DBig::from_repr_const(Repr::one()), DBig::ONE);
assert_eq!(DBig::from_repr_const(Repr::infinity()), DBig::INFINITY);

pub const fn precision(&self) -> usize

Get the maximum precision set for the float number.

It’s equivalent to self.context().precision().

Examples

use dashu_float::Repr;

let a = DBig::from_str("1.234")?;
assert!(a.repr().significand() <= &IBig::from(10).pow(a.precision()));

pub fn digits(&self) -> usize

Get the number of the significant digits in the float number

It’s equivalent to self.repr().digits().

This value is also the actual precision needed for the float number. Shrink to this value using with_precision() will not cause loss of float precision.

Examples

use dashu_base::Approximation::*;

let a = DBig::from_str("-1.234e-3")?;
assert_eq!(a.digits(), 4);
assert!(matches!(a.clone().with_precision(4), Exact(_)));
assert!(matches!(a.clone().with_precision(3), Inexact(_, _)));

pub const fn context(&self) -> Context<R>

Get the context associated with the float number

pub const fn repr(&self) -> &Repr<B>

Get a reference to the underlying numeric representation

pub fn into_repr(self) -> Repr<B>

Get the underlying numeric representation

Examples

use dashu_float::Repr;

let a = DBig::ONE;
assert_eq!(a.into_repr(), Repr::<10>::one());

pub fn from_parts(significand: IBig, exponent: isize) -> Self

Convert raw parts (significand, exponent) into a float number.

The precision will be inferred from significand (the lowest k such that significand <= base^k)

Examples

use core::str::FromStr;
let a = DBig::from_parts((-1234).into(), -2);
assert_eq!(a, DBig::from_str("-12.34")?);
assert_eq!(a.precision(), 4); // 1234 has 4 (decimal) digits

pub const fn from_parts_const( sign: Sign, significand: DoubleWord, exponent: isize, min_precision: Option<usize>, ) -> Self

Convert raw parts (significand, exponent) into a float number in a const context.

It requires that the significand fits in a DoubleWord.

The precision will be inferred from significand (the lowest k such that significand <= base^k). If the min_precision is provided, then the higher one from the given and inferred precision will be used as the final precision.

Examples

use core::str::FromStr;
use dashu_base::Sign;

const A: DBig = DBig::from_parts_const(Sign::Negative, 1234, -2, None);
assert_eq!(A, DBig::from_str("-12.34")?);
assert_eq!(A.precision(), 4); // 1234 has 4 (decimal) digits

const B: DBig = DBig::from_parts_const(Sign::Negative, 1234, -2, Some(5));
assert_eq!(B.precision(), 5); // overrided by the argument

pub fn ulp(&self) -> Self

Return the value of the least significant digit of the float number x, such that x + ulp is the first float number greater than x (given the precision from the context).

Examples

assert_eq!(DBig::from_str("1.23")?.ulp(), DBig::from_str("0.01")?);
assert_eq!(DBig::from_str("01.23")?.ulp(), DBig::from_str("0.001")?);

Panics

Panics if the precision of the number is 0 (unlimited).

impl<R: Round, const B: Word> FBig<R, B>

pub fn into_cached(self, cache: Rc<RefCell<ConstCache>>) -> CachedFBig<R, B>

Attach a shared cache handle, turning this FBig into a CachedFBig.

impl<R: Round, const B: Word> FBig<R, B>

pub fn ln(&self) -> Self

Calculate the natural logarithm function (log(x)) on the float number.

Examples

let a = DBig::from_str("1.234")?;
assert_eq!(a.ln(), DBig::from_str("0.2103")?);

pub fn ln_1p(&self) -> Self

Calculate the natural logarithm function (log(x+1)) on the float number

Examples

let a = DBig::from_str("0.1234")?;
assert_eq!(a.ln_1p(), DBig::from_str("0.11636")?);

impl<R: Round, const B: Word> FBig<R, B>

pub fn sinh(&self) -> Self

Calculate the hyperbolic sine of the floating point number.

Examples

let a = DBig::from_str("0.5000000")?;
assert_eq!(a.sinh(), DBig::from_str("0.52109531")?);

pub fn cosh(&self) -> Self

Calculate the hyperbolic cosine of the floating point number.

Examples

let a = DBig::from_str("0.5000000")?;
assert_eq!(a.cosh(), DBig::from_str("1.127626")?);

pub fn sinh_cosh(&self) -> (Self, Self)

Simultaneously calculate the hyperbolic sine and cosine of the number.

This is more efficient than calling sinh and cosh separately, since the two share the exp_m1(±x) sub-computations.

Examples

let a = DBig::from_str("0.5000000")?;
let (s, c) = a.sinh_cosh();
assert_eq!(s, DBig::from_str("0.52109531")?);
assert_eq!(c, DBig::from_str("1.127626")?);

pub fn tanh(&self) -> Self

Calculate the hyperbolic tangent of the floating point number.

Examples

let a = DBig::from_str("0.5000000")?;
assert_eq!(a.tanh(), DBig::from_str("0.46211716")?);

pub fn asinh(&self) -> Self

Calculate the inverse hyperbolic sine of the floating point number.

Examples

let a = DBig::from_str("0.5000000")?;
assert_eq!(a.asinh(), DBig::from_str("0.48121183")?);

pub fn acosh(&self) -> Self

Calculate the inverse hyperbolic cosine of the floating point number.

Panics

Panics if the number is less than 1 (out of domain).

Examples

let a = DBig::from_str("2.000000")?;
assert_eq!(a.acosh(), DBig::from_str("1.316958")?);

pub fn atanh(&self) -> Self

Calculate the inverse hyperbolic tangent of the floating point number.

Panics

Panics if the absolute value is greater than or equal to 1 (out of domain; |x| = 1 is infinite and |x| > 1 is not real).

Examples

let a = DBig::from_str("0.5000000")?;
assert_eq!(a.atanh(), DBig::from_str("0.54930614")?);

impl<R: Round, const B: Word> FBig<R, B>

pub fn sin(&self) -> Self

Calculate the sine of the floating point number.

Panics

Panics if the input is infinite.

pub fn cos(&self) -> Self

Calculate the cosine of the floating point number.

Panics

Panics if the input is infinite.

pub fn sin_cos(&self) -> (Self, Self)

Calculate both the sine and cosine of the floating point number.

This is more efficient than calling sin and cos separately.

Panics

Panics if the input is infinite.

pub fn tan(&self) -> Self

Calculate the tangent of the floating point number.

At odd multiples of π/2 the result is an infinity (returned as a value).

Panics

Panics if the input is infinite.

pub fn asin(&self) -> Self

Calculate the arcsine of the floating point number.

Panics

Panics if the input is infinite or |self| > 1 (out of domain).

pub fn acos(&self) -> Self

Calculate the arccosine of the floating point number.

Panics

Panics if the input is infinite or |self| > 1 (out of domain).

pub fn atan(&self) -> Self

Calculate the arctangent of the floating point number. atan(±inf) = ±π/2.

pub fn atan2(&self, x: &Self) -> Self

Calculate the arctangent of self / x.

Panics

Panics if both arguments are zero.

impl<R: Round, const B: Word> FBig<R, B>

pub fn pi(precision: usize) -> Self

Calculate π with the given precision and the default rounding mode.

impl<R: Round, const B: Word> FBig<R, B>

pub fn sqr(&self) -> Self

Compute the square of this number (self * self)

Examples

let a = DBig::from_str("-1.234")?;
assert_eq!(a.sqr(), DBig::from_str("1.523")?);

pub fn cubic(&self) -> Self

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

Examples

let a = DBig::from_str("-1.234")?;
assert_eq!(a.cubic(), DBig::from_str("-1.879")?);

impl<R: Round, const B: Word> FBig<R, B>

pub fn sqrt(&self) -> Self

Calculate the square root of the floating point number.

Panics

Panics if the precision is unlimited.

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

Calculate the nth root of the floating point number.

When n is large the computation can be expensive — the significand is padded to n · precision digits before the integer root is taken, and the integer Newton iteration works with numbers of that size. For large n consider powf with a rational exponent 1 / n as a faster approximate alternative.

Examples

let a = DBig::from_str("16")?;
assert_eq!(a.nth_root(4), DBig::from_str("2")?);

Panics

Panics if n is zero, or if n is even and the number is negative.

impl<R: Round, const B: Word> FBig<R, B>

pub fn hypot(&self, other: &Self) -> Self

Compute sqrt(self² + other²) without spurious overflow/underflow.

The result precision is max(self.precision(), other.precision()). See Context::hypot for the overflow-safety strategy.

Examples

let a = DBig::from_str("3")?;
let b = DBig::from_str("4")?;
assert_eq!(a.hypot(&b), DBig::from_str("5")?);

Panics

Panics if the precision is unlimited.

impl<R: Round, const B: Word> FBig<R, B>

pub fn trunc(&self) -> Self

Get the integral part of the float

See FBig::round for how the output precision is determined.

Examples

let a = DBig::from_str("1.234")?;
assert_eq!(a.trunc(), DBig::from_str("1")?);
// the actual precision of the integral part is 1 digit
assert_eq!(a.trunc().precision(), 1);

Panics

Panics if the number is infinte

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

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

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

Examples

let a = DBig::from_str("1.234")?;
let (trunc, fract) = a.split_at_point();
assert_eq!(trunc, DBig::from_str("1.0")?);
assert_eq!(fract, DBig::from_str("0.234")?);
// the actual precision of the fractional part is 3 digits
assert_eq!(trunc.precision(), 1);
assert_eq!(fract.precision(), 3);

pub fn fract(&self) -> Self

Get the fractional part of the float

Note: this function will adjust the precision accordingly!

Examples

let a = DBig::from_str("1.234")?;
assert_eq!(a.fract(), DBig::from_str("0.234")?);
// the actual precision of the fractional part is 3 digits
assert_eq!(a.fract().precision(), 3);

Panics

Panics if the number is infinte

pub fn ceil(&self) -> Self

Returns the smallest integer greater than or equal to self.

See FBig::round for how the output precision is determined.

Examples

let a = DBig::from_str("1.234")?;
assert_eq!(a.ceil(), DBig::from_str("2")?);

// works for very large exponent
let b = DBig::from_str("1.234e10000")?;
assert_eq!(b.ceil(), b);

Panics

Panics if the number is infinte

pub fn floor(&self) -> Self

Returns the largest integer less than or equal to self.

See FBig::round for how the output precision is determined.

Examples

let a = DBig::from_str("1.234")?;
assert_eq!(a.floor(), DBig::from_str("1")?);

// works for very large exponent
let b = DBig::from_str("1.234e10000")?;
assert_eq!(b.floor(), b);

Panics

Panics if the number is infinte

pub fn round(&self) -> Self

Returns the integer nearest to self.

If there are two integers equally close, then the one farther from zero is chosen.

Examples

let a = DBig::from_str("1.234")?;
assert_eq!(a.round(), DBig::from_str("1")?);

// works for very large exponent
let b = DBig::from_str("1.234e10000")?;
assert_eq!(b.round(), b);

Precision

If self is an integer, the result will have the same precision as self. If self has fractional part, then the precision will be subtracted by the digits in the fractional part. Examples:

• 1.00e100 (precision = 3) rounds to 1.00e100 (precision = 3)
• 1.234 (precision = 4) rounds to 1. (precision = 1)
• 1.234e-10 (precision = 4) rounds to 0. (precision = 0, i.e arbitrary precision)

Panics

Panics if the number is infinte

pub fn quantize(&self, exp: isize) -> Rounded<Self>

Round the number to the nearest multiple of BASE^exp.

This is the dashu analog of Python’s Decimal.quantize(). The result’s value is an exact multiple of BASE^exp, and its precision is set so that ulp() equals BASE^exp. Because dashu floats are normalized, trailing zeros are not preserved in storage (the stored exponent may be coarser than exp), but the value and ULP are exact. The result keeps self’s rounding mode.

Examples

use dashu_base::Approximation::*;
use dashu_float::round::Rounding::*;

let a = DBig::from_str("1.234")?; // precision 4

// round to 2 fractional digits (exp = -2): 3 significant figures remain
assert_eq!(a.quantize(-2), Inexact(DBig::from_str("1.23")?, NoOp));
assert_eq!(a.quantize(-2).value().precision(), 3);

// a finer quantum is exact (no rounding) and *increases* the precision
assert_eq!(a.quantize(-10), Exact(DBig::from_str("1.234")?));
assert_eq!(a.quantize(-10).value().precision(), 11);

// round to integer (exp = 0), or to the nearest 1000 (exp = 3)
assert_eq!(a.quantize(0), Inexact(DBig::from_str("1")?, NoOp));
assert_eq!(DBig::from_str("999")?.quantize(3), Inexact(DBig::from_str("1000")?, AddOne));

Panics

Panics if the number is infinte

impl<R: Round, const B: Word> FBig<R, B>

pub const fn sign(&self) -> Sign

Get the sign of the number. Positive zero has a positive sign, negative zero has a negative sign.

Examples

assert_eq!(DBig::ZERO.sign(), Sign::Positive);
assert_eq!(DBig::from_str("-1.234")?.sign(), Sign::Negative);

pub const fn signum(&self) -> Self

A number representing the sign of self.

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

Examples

assert_eq!(DBig::from_str("2.01")?.signum(), DBig::ONE);
assert_eq!(DBig::from_str("-1.234")?.signum(), DBig::NEG_ONE);

Trait Implementations

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

type Output = FBig<R, B>

The type of the absolute value.

fn abs(self) -> Self::Output

Compute the absolute value.

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

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

Compare the magnitude of self against the magnitude of rhs.

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

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

Compare the magnitude of self against the magnitude of rhs.

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

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

Compare the magnitude of self against the magnitude of rhs.

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

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

Compare the magnitude of self against the magnitude of rhs.

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

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

Compare the magnitude of self against the magnitude of rhs.

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

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for u8

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l u8

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for u16

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l u16

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for u32

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l u32

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for u64

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l u64

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for u128

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l u128

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for usize

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l usize

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for UBig

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l UBig

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for i8

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l i8

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for i16

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l i16

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for i32

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l i32

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for i64

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l i64

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for i128

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l i128

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for isize

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l isize

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for IBig

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l IBig

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r IBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r IBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r UBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r UBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r i8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r i8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r i16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r i16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r i32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r i32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r i64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r i64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r i128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r i128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r isize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r isize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r u8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r u8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r u16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r u16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r u32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r u32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r u64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r u64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r u128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r u128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'r, R: Round, const B: Word> Add<&'r usize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, 'r, R: Round, const B: Word> Add<&'r usize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<&FBig<R, B>> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<&FBig<R, B>> for &FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for &FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for u8

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l u8

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for u16

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l u16

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for u32

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l u32

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for u64

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l u64

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for u128

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l u128

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for usize

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l usize

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for UBig

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l UBig

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for i8

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l i8

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for i16

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l i16

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for i32

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l i32

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for i64

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l i64

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for i128

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l i128

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for isize

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l isize

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for IBig

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l IBig

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: FBig<R, B>) -> Self::Output

Performs the + operation.

impl<R: Round, const B: Word> Add<IBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<IBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<UBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<UBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<i8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<i8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<i16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<i16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<i32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<i32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<i64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<i64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<i128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<i128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<isize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<isize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<u8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<u8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<u16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<u16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<u32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<u32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<u64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<u64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<u128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<u128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R: Round, const B: Word> Add<usize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l, R: Round, const B: Word> Add<usize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

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

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&FBig<R, B>> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&FBig<R, B>> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: &FBig<R, B>)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&IBig> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&UBig> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&i8> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&i16> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&i32> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&i64> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&i128> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&isize> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&u8> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&u16> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&u32> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&u64> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&u128> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<&usize> for FBig<R, B>

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

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<FBig<R, B>> for CachedFBig<R, B>

fn add_assign(&mut self, rhs: FBig<R, B>)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<IBig> for FBig<R, B>

fn add_assign(&mut self, rhs: IBig)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<UBig> for FBig<R, B>

fn add_assign(&mut self, rhs: UBig)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<i8> for FBig<R, B>

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<i16> for FBig<R, B>

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<i32> for FBig<R, B>

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<i64> for FBig<R, B>

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<i128> for FBig<R, B>

fn add_assign(&mut self, rhs: i128)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<isize> for FBig<R, B>

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<u8> for FBig<R, B>

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<u16> for FBig<R, B>

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<u32> for FBig<R, B>

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<u64> for FBig<R, B>

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<u128> for FBig<R, B>

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl<R: Round, const B: Word> AddAssign<usize> for FBig<R, B>

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl<R: Round> Binary for FBig<R, 2>

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

Formats the value using the given formatter.

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

type Output = FBig<R, B>

The type of the cubic root.

fn cbrt(&self) -> Self

Compute the cubic root, rounded towards zero by default.

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Default value: 0.

impl<'de, R: Round, const B: Word> Deserialize<'de> for FBig<R, B>

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

Deserialize this value from the given Serde deserializer.

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

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

Formats the value using the given formatter.

impl<R: Round, const B: Word> Distribution<FBig<R, B>> for UniformFBig<R, B>

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

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<R: Round, const B: Word> Distribution<FBig<R, B>> for Uniform01<B>

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

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<R: Round, const B: Word> Distribution<FBig<R, B>> for Standard

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

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<R: Round, const B: Word> Distribution<FBig<R, B>> for Open01

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

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<R: Round, const B: Word> Distribution<FBig<R, B>> for OpenClosed01

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

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<R: Round, const B: Word> Distribution<FBig<R, B>> for UniformFBig<R, B>

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

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

fn sample_iter<R>(self, rng: R) -> Iter<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) -> Map<Self, F, T, S>

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

Map sampled values to type S

impl<R: Round, const B: Word> Distribution<FBig<R, B>> for Uniform01<B>

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

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

fn sample_iter<R>(self, rng: R) -> Iter<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) -> Map<Self, F, T, S>

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

Map sampled values to type S

impl<R: Round, const B: Word> Distribution<FBig<R, B>> for StandardUniform

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

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

fn sample_iter<R>(self, rng: R) -> Iter<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) -> Map<Self, F, T, S>

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

Map sampled values to type S

impl<R: Round, const B: Word> Distribution<FBig<R, B>> for Open01

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

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

fn sample_iter<R>(self, rng: R) -> Iter<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) -> Map<Self, F, T, S>

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

Map sampled values to type S

impl<R: Round, const B: Word> Distribution<FBig<R, B>> for OpenClosed01

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

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

fn sample_iter<R>(self, rng: R) -> Iter<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) -> Map<Self, F, T, S>

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

Map sampled values to type S

impl<R: Round, const B: Word> Distribution<FBig<R, B>> for UniformFBig<R, B>

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

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

fn sample_iter<R>(self, rng: R) -> Iter<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) -> Map<Self, F, T, S>

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

Map sampled values to type S

impl<R: Round, const B: Word> Distribution<FBig<R, B>> for Uniform01<B>

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

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

fn sample_iter<R>(self, rng: R) -> Iter<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) -> Map<Self, F, T, S>

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

Map sampled values to type S

impl<R: Round, const B: Word> Distribution<FBig<R, B>> for StandardUniform

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

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

fn sample_iter<R>(self, rng: R) -> Iter<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) -> Map<Self, F, T, S>

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

Map sampled values to type S

impl<R: Round, const B: Word> Distribution<FBig<R, B>> for Open01

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

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

fn sample_iter<R>(self, rng: R) -> Iter<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) -> Map<Self, F, T, S>

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

Map sampled values to type S

impl<R: Round, const B: Word> Distribution<FBig<R, B>> for OpenClosed01

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

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

fn sample_iter<R>(self, rng: R) -> Iter<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) -> Map<Self, F, T, S>

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

Map sampled values to type S

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

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for u8

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l u8

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for u16

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l u16

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for u32

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l u32

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for u64

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l u64

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for u128

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l u128

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for usize

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l usize

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for UBig

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l UBig

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for i8

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l i8

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for i16

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l i16

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for i32

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l i32

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for i64

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l i64

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for i128

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l i128

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for isize

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l isize

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for IBig

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l IBig

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r IBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r IBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r UBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r UBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r i8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r i8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r i16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r i16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r i32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r i32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r i64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r i64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r i128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r i128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r isize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r isize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r u8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r u8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r u16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r u16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r u32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r u32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r u64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r u64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r u128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r u128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'r, R: Round, const B: Word> Div<&'r usize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, 'r, R: Round, const B: Word> Div<&'r usize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for u8

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l u8

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for u16

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l u16

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for u32

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l u32

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for u64

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l u64

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for u128

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l u128

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for usize

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l usize

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for UBig

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l UBig

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for i8

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l i8

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for i16

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l i16

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for i32

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l i32

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for i64

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l i64

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for i128

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l i128

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for isize

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l isize

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for IBig

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l IBig

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> Self::Output

Performs the / operation.

impl<R: Round, const B: Word> Div<IBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<IBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<UBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<UBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<i8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<i8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<i16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<i16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<i32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<i32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<i64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<i64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<i128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<i128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<isize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<isize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<u8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<u8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<u16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<u16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<u32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<u32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<u64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<u64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<u128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<u128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R: Round, const B: Word> Div<usize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l, R: Round, const B: Word> Div<usize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

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

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&FBig<R, B>> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&FBig<R, B>> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: &FBig<R, B>)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&IBig> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&UBig> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&i8> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&i16> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&i32> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&i64> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&i128> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&isize> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&u8> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&u16> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&u32> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&u64> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&u128> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<&usize> for FBig<R, B>

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

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<FBig<R, B>> for CachedFBig<R, B>

fn div_assign(&mut self, rhs: FBig<R, B>)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<IBig> for FBig<R, B>

fn div_assign(&mut self, rhs: IBig)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<UBig> for FBig<R, B>

fn div_assign(&mut self, rhs: UBig)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<i8> for FBig<R, B>

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<i16> for FBig<R, B>

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<i32> for FBig<R, B>

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<i64> for FBig<R, B>

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<i128> for FBig<R, B>

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<isize> for FBig<R, B>

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<u8> for FBig<R, B>

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<u16> for FBig<R, B>

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<u32> for FBig<R, B>

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<u64> for FBig<R, B>

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<u128> for FBig<R, B>

fn div_assign(&mut self, rhs: u128)

Performs the /= operation.

impl<R: Round, const B: Word> DivAssign<usize> for FBig<R, B>

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

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

type Output = IBig

The type of the quotient.

fn div_euclid(self, rhs: FBig<R, B>) -> Self::Output

Compute the Euclidean quotient of self / rhs.

impl<R: Round, const B: Word> DivEuclid<&FBig<R, B>> for FBig<R, B>

type Output = IBig

The type of the quotient.

fn div_euclid(self, rhs: &FBig<R, B>) -> Self::Output

Compute the Euclidean quotient of self / rhs.

impl<R: Round, const B: Word> DivEuclid<&FBig<R, B>> for &FBig<R, B>

type Output = IBig

The type of the quotient.

fn div_euclid(self, rhs: &FBig<R, B>) -> Self::Output

Compute the Euclidean quotient of self / rhs.

impl<R: Round, const B: Word> DivEuclid<FBig<R, B>> for &FBig<R, B>

type Output = IBig

The type of the quotient.

fn div_euclid(self, rhs: FBig<R, B>) -> Self::Output

Compute the Euclidean quotient of self / rhs.

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

type OutputDiv = IBig

The type of the quotient.

type OutputRem = FBig<R, B>

The type of the remainder.

fn div_rem_euclid(self, rhs: FBig<R, B>) -> (IBig, FBig<R, B>)

Compute the Euclidean quotient and remainder at the same time.

impl<R: Round, const B: Word> DivRemEuclid<&FBig<R, B>> for FBig<R, B>

type OutputDiv = IBig

The type of the quotient.

type OutputRem = FBig<R, B>

The type of the remainder.

fn div_rem_euclid(self, rhs: &FBig<R, B>) -> (IBig, FBig<R, B>)

Compute the Euclidean quotient and remainder at the same time.

impl<R: Round, const B: Word> DivRemEuclid<&FBig<R, B>> for &FBig<R, B>

type OutputDiv = IBig

The type of the quotient.

type OutputRem = FBig<R, B>

The type of the remainder.

fn div_rem_euclid(self, rhs: &FBig<R, B>) -> (IBig, FBig<R, B>)

Compute the Euclidean quotient and remainder at the same time.

impl<R: Round, const B: Word> DivRemEuclid<FBig<R, B>> for &FBig<R, B>

type OutputDiv = IBig

The type of the quotient.

type OutputRem = FBig<R, B>

The type of the remainder.

fn div_rem_euclid(self, rhs: FBig<R, B>) -> (IBig, FBig<R, B>)

Compute the Euclidean quotient and remainder at the same time.

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

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

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<R: Round, const B: Word> Euclid for FBig<R, B>

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<R: Round, const B: Word> From<CachedFBig<R, B>> for FBig<R, B>

fn from(cached: CachedFBig<R, B>) -> Self

Converts to this type from the input type.

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

fn from(fbig: FBig<R, B>) -> Self

Converts to this type from the input type.

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

fn from(n: IBig) -> Self

Converts to this type from the input type.

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

fn from(n: UBig) -> Self

Converts to this type from the input type.

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

fn from(value: i8) -> FBig<R, B>

Converts to this type from the input type.

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

fn from(value: i16) -> FBig<R, B>

Converts to this type from the input type.

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

fn from(value: i32) -> FBig<R, B>

Converts to this type from the input type.

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

fn from(value: i64) -> FBig<R, B>

Converts to this type from the input type.

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

fn from(value: i128) -> FBig<R, B>

Converts to this type from the input type.

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

fn from(value: isize) -> FBig<R, B>

Converts to this type from the input type.

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

fn from(value: u8) -> FBig<R, B>

Converts to this type from the input type.

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

fn from(value: u16) -> FBig<R, B>

Converts to this type from the input type.

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

fn from(value: u32) -> FBig<R, B>

Converts to this type from the input type.

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

fn from(value: u64) -> FBig<R, B>

Converts to this type from the input type.

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

fn from(value: u128) -> FBig<R, B>

Converts to this type from the input type.

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

fn from(value: usize) -> FBig<R, B>

Converts to this type from the input type.

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

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<'a, R: Round> FromSql<'a> for FBig<R, 10>

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be created from the specified Postgres Type.

fn from_sql( ty: &Type, raw: &'a [u8], ) -> Result<Self, Box<dyn Error + Sync + Send>>

Creates a new value of this type from a buffer of data of the specified Postgres Type in its binary format.

fn from_sql_null(ty: &Type) -> Result<Self, Box<dyn Error + Sync + Send>>

Creates a new value of this type from a NULL SQL value.

fn from_sql_nullable( ty: &Type, raw: Option<&'a [u8]>, ) -> Result<Self, Box<dyn Error + Sync + Send>>

A convenience function that delegates to from_sql and from_sql_null depending on the value of raw.

impl<R: Round> FromSql<Numeric, Pg> for FBig<R, 10>

fn from_sql(bytes: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl<R: Round> FromSql<Numeric, Pg> for FBig<R, 10>

fn from_sql(bytes: PgValue<'_>) -> Result<Self>

See the trait documentation.

fn from_nullable_sql( bytes: Option<<DB as Backend>::RawValue<'_>>, ) -> Result<Self, Box<dyn Error + Sync + Send>>

A specialized variant of from_sql for handling null values.

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

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

Convert a string in the native base (i.e. radix B) to FBig.

If parsing succeeds, the result is losslessly parsed from the input string, and its precision equals the number of significant digits in the input.

Note: Infinites are intentionally not supported by this function.

Format

The valid representations include

1. aaa or aaa.
   • aaa is represented in native base B without base prefixes.
2. aaa.bbb = aaabbb / base ^ len(bbb)
   • aaa and bbb are represented in native base B without base prefixes.
   • len(bbb) represents the number of digits in bbb, e.g len(bbb) is 3. (Same below)
3. aaa.bbb@cc = aaabbb * base ^ (cc - len(bbb))
   • aaa and bbb are represented in native base B
   • This is consistent with the representation used by GNU GMP.
4. aaa.bbbEcc = aaabbb * 10 ^ (cc - len(bbb))
   • E could be lower case, base B must be 10
   • aaa and bbb are all represented in decimal
5. 0xaaa or 0xaaa
6. 0xaaa.bbb = 0xaaabbb / 16 ^ len(bbb)
7. 0xaaa.bbbPcc = 0xaaabbb / 16 ^ len(bbb) * 2 ^ cc
   • P could be lower case, base B must be 2 (not 16!)
   • aaa and bbb are represented in hexadecimal
   • This is consistent with the C++ hexadecimal literals.
8. aaa.bbbBcc = aaabbb * 2 ^ (cc - len(bbb))
9. aaa.bbbOcc = aaabbb * 8 ^ (cc - len(bbb))
10. aaa.bbbHcc = aaabbb * 16 ^ (cc - len(bbb))
    • B/O/H could be lower case, and base B must be consistent with the marker.
    • aaa and bbb are represented in binary/octal/hexadecimal correspondingly without prefix.
    • This is consistent with some scientific notations described in Wikipedia.

Digits 10-35 are represented by a-z or A-Z.

Literal aaa and cc above can be signed, but bbb must be unsigned. All cc are represented in decimal. Either aaa or bbb can be omitted when its value is zero, but they are not allowed to be omitted at the same time.

Precision

The precision of the parsed number is determined by the number of digits that are presented in the input string. For example, the numbers parsed from 12.34 or 1.234e-1 will have a precision of 4, while the ones parsed from 12.34000 or 00012.34 will have a precision of 7.

Panics

Panics if the base B is not between MIN_RADIX and MAX_RADIX inclusive.

Examples

let a = DBig::from_str("-1.23400e-3")?;
let b = DBig::from_str("-123.4@-05")?;
assert_eq!(a, b);
assert_eq!(a.precision(), 6);
assert_eq!(b.precision(), 4);

assert!(DBig::from_str("-0x1.234p-3").is_err());
assert!(DBig::from_str("-1.234H-3").is_err());

type Err = ParseError

The associated error which can be returned from parsing.

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

type Output = FBig<R, B>

The type of the reciprocal.

fn inv(self) -> Self::Output

Compute the multiplicative inverse (reciprocal) of the number.

impl<R: Round, const B: Word> Inverse for &FBig<R, B>

type Output = FBig<R, B>

The type of the reciprocal.

fn inv(self) -> Self::Output

Compute the multiplicative inverse (reciprocal) of the number.

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

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

Formats the value using the given formatter.

impl<R: Round> LowerHex for FBig<R, 2>

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

Formats the value using the given formatter.

impl<R: Round> LowerHex for FBig<R, 16>

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

Formats the value using the given formatter.

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

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for u8

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l u8

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for u16

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l u16

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for u32

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l u32

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for u64

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l u64

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for u128

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l u128

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for usize

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l usize

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for UBig

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l UBig

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for i8

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l i8

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for i16

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l i16

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for i32

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l i32

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for i64

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l i64

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for i128

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l i128

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for isize

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l isize

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for IBig

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r FBig<R, B>> for &'l IBig

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r IBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r IBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r UBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r UBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r i8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r i8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r i16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r i16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r i32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r i32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r i64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r i64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r i128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r i128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r isize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r isize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r u8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r u8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r u16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r u16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r u32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r u32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r u64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r u64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r u128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r u128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R: Round, const B: Word> Mul<&'r usize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, 'r, R: Round, const B: Word> Mul<&'r usize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<&FBig<R, B>> for &FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<&FBig<R, B>> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for &FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for u8

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l u8

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for u16

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l u16

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for u32

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l u32

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for u64

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l u64

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for u128

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l u128

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for usize

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l usize

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for UBig

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l UBig

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for i8

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l i8

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for i16

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l i16

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for i32

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l i32

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for i64

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l i64

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for i128

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l i128

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for isize

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l isize

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for IBig

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<FBig<R, B>> for &'l IBig

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<FBig<R, B>> for Sign

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> Self::Output

Performs the * operation.

impl<R: Round, const B: Word> Mul<IBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<IBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<Sign> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<UBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<UBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<i8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<i8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<i16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<i16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<i32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<i32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<i64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<i64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<i128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<i128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<isize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<isize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<u8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<u8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<u16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<u16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<u32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<u32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<u64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<u64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<u128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<u128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R: Round, const B: Word> Mul<usize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l, R: Round, const B: Word> Mul<usize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

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

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&FBig<R, B>> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: &FBig<R, B>)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&FBig<R, B>> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&IBig> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&UBig> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&i8> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&i16> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&i32> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&i64> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&i128> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&isize> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&u8> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&u16> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&u32> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&u64> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&u128> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<&usize> for FBig<R, B>

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

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<FBig<R, B>> for CachedFBig<R, B>

fn mul_assign(&mut self, rhs: FBig<R, B>)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<IBig> for FBig<R, B>

fn mul_assign(&mut self, rhs: IBig)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<Sign> for FBig<R, B>

fn mul_assign(&mut self, rhs: Sign)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<UBig> for FBig<R, B>

fn mul_assign(&mut self, rhs: UBig)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<i8> for FBig<R, B>

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<i16> for FBig<R, B>

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<i32> for FBig<R, B>

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<i64> for FBig<R, B>

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<i128> for FBig<R, B>

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<isize> for FBig<R, B>

fn mul_assign(&mut self, rhs: isize)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<u8> for FBig<R, B>

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<u16> for FBig<R, B>

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<u32> for FBig<R, B>

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<u64> for FBig<R, B>

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<u128> for FBig<R, B>

fn mul_assign(&mut self, rhs: u128)

Performs the *= operation.

impl<R: Round, const B: Word> MulAssign<usize> for FBig<R, B>

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

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

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R: Round, const B: Word> Neg for &FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

type FromStrRadixErr = ParseError

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

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

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

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

Consistent Hash::hash on different numeric types.

impl<R1: Round, R2: Round, const B1: Word, const B2: Word> NumOrd<FBig<R2, B2>> for FBig<R1, B1>

fn num_cmp(&self, other: &FBig<R2, B2>) -> Ordering

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

fn num_partial_cmp(&self, other: &FBig<R2, B2>) -> 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: Round, const B: Word> NumOrd<FBig<R, B>> for UBig

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<R: Round, const B: Word> NumOrd<FBig<R, B>> for IBig

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<R: Round, const B: Word> NumOrd<FBig<R, B>> for u8

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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<R: Round, const B: Word> NumOrd<FBig<R, B>> for f64

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<R: Round, const B: Word> NumOrd<IBig> for FBig<R, B>

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: Round, const B: Word> NumOrd<UBig> for FBig<R, B>

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<R: Round, const B: Word> NumOrd<f32> for FBig<R, B>

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<R: Round, const B: Word> NumOrd<f64> for FBig<R, B>

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<R: Round, const B: Word> NumOrd<i8> for FBig<R, B>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<R: Round> Octal for FBig<R, 8>

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

Formats the value using the given formatter.

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

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<R: Round, const B: Word> Ord for FBig<R, B>

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<R1: Round, R2: Round, const B: Word> PartialEq<FBig<R2, B>> for FBig<R1, B>

fn eq(&self, other: &FBig<R2, B>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<R1: Round, R2: Round, const B: Word> PartialOrd<FBig<R2, B>> for FBig<R1, B>

fn partial_cmp(&self, other: &FBig<R2, B>) -> 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<R: Round, const B: Word> Pow<&FBig<R, B>> for FBig<R, B>

type Output = FBig<R, B>

The result after applying the operator.

fn pow(self, rhs: &Self) -> Self

Returns self to the power rhs.

impl<R: Round, const B: Word> Pow<&FBig<R, B>> for &FBig<R, B>

type Output = FBig<R, B>

The result after applying the operator.

fn pow(self, rhs: &FBig<R, B>) -> FBig<R, B>

Returns self to the power rhs.

impl<R: Round, const B: Word> Pow<IBig> for FBig<R, B>

type Output = FBig<R, B>

The result after applying the operator.

fn pow(self, rhs: IBig) -> Self

Returns self to the power rhs.

impl<R: Round, const B: Word> Pow<IBig> for &FBig<R, B>

type Output = FBig<R, B>

The result after applying the operator.

fn pow(self, rhs: IBig) -> FBig<R, B>

Returns self to the power rhs.

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

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, R: Round, const B: Word> Product<&'a FBig<R, B>> for FBig<R, B>

fn product<I: Iterator<Item = &'a FBig<R, B>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

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

type Output = FBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: FBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r FBig<R, B>> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &FBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r FBig<R, B>> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &FBig<R, B>) -> Self::Output

Performs the % operation.

impl<'r, R: Round, const B: Word> Rem<&'r FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &FBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, 'r, R: Round, const B: Word> Rem<&'r FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &FBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<FBig<R, B>> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: FBig<R, B>) -> Self::Output

Performs the % operation.

impl<R: Round, const B: Word> Rem<FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: FBig<R, B>) -> Self::Output

Performs the % operation.

impl<'l, R: Round, const B: Word> Rem<FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: FBig<R, B>) -> Self::Output

Performs the % operation.

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

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&FBig<R, B>> for FBig<R, B>

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

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<&FBig<R, B>> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: &FBig<R, B>)

Performs the %= operation.

impl<R: Round, const B: Word> RemAssign<FBig<R, B>> for CachedFBig<R, B>

fn rem_assign(&mut self, rhs: FBig<R, B>)

Performs the %= operation.

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

type Output = FBig<R, B>

The type of the remainder.

fn rem_euclid(self, rhs: FBig<R, B>) -> Self::Output

Compute the non-negative Euclidean remainder of self % rhs.

impl<R: Round, const B: Word> RemEuclid<&FBig<R, B>> for FBig<R, B>

type Output = FBig<R, B>

The type of the remainder.

fn rem_euclid(self, rhs: &FBig<R, B>) -> Self::Output

Compute the non-negative Euclidean remainder of self % rhs.

impl<R: Round, const B: Word> RemEuclid<&FBig<R, B>> for &FBig<R, B>

type Output = FBig<R, B>

The type of the remainder.

fn rem_euclid(self, rhs: &FBig<R, B>) -> Self::Output

Compute the non-negative Euclidean remainder of self % rhs.

impl<R: Round, const B: Word> RemEuclid<FBig<R, B>> for &FBig<R, B>

type Output = FBig<R, B>

The type of the remainder.

fn rem_euclid(self, rhs: FBig<R, B>) -> Self::Output

Compute the non-negative Euclidean remainder of self % rhs.

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

type Sampler = UniformFBig<R, B>

The UniformSampler implementation supporting type X.

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

type Sampler = UniformFBig<R, B>

The UniformSampler implementation supporting type X.

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

type Sampler = UniformFBig<R, B>

The UniformSampler implementation supporting type X.

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

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

Serialize this value into the given Serde serializer.

impl<R: Round, const B: Word> Shl<isize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<R: Round, const B: Word> ShlAssign<isize> for FBig<R, B>

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation.

impl<R: Round, const B: Word> Shr<isize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<R: Round, const B: Word> ShrAssign<isize> for FBig<R, B>

fn shr_assign(&mut self, rhs: isize)

Performs the >>= operation.

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

fn sign(&self) -> Sign

Return the sign of the number.

fn is_positive(&self) -> bool

Returns true if the number is positive (including positive zero).

fn is_negative(&self) -> bool

Returns true if the number is negative.

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

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<R: Round, const B: Word> SquareRoot for FBig<R, B>

type Output = FBig<R, B>

The type of the square root.

fn sqrt(&self) -> Self

Compute the square root, rounded towards zero by default.

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

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for u8

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l u8

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for u16

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l u16

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for u32

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l u32

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for u64

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l u64

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for u128

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l u128

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for usize

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l usize

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for UBig

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l UBig

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for i8

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l i8

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for i16

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l i16

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for i32

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l i32

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for i64

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l i64

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for i128

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l i128

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for isize

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l isize

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for IBig

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l IBig

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r IBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r IBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r UBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r UBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r i8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r i8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r i16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r i16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r i32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r i32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r i64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r i64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r i128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r i128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r isize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r isize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r u8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r u8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r u16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r u16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r u32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r u32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r u64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r u64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r u128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> Self::Output

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r u128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> Self::Output

Performs the - operation.

impl<'r, R: Round, const B: Word> Sub<&'r usize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, 'r, R: Round, const B: Word> Sub<&'r usize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R: Round, const B: Word> Sub<&FBig<R, B>> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<&FBig<R, B>> for &FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<CachedFBig<R, B>> for FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<CachedFBig<R, B>> for &'l FBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: CachedFBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for &FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for u8

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l u8

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for u16

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l u16

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for u32

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l u32

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for u64

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l u64

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for u128

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l u128

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for usize

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l usize

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for UBig

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l UBig

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for i8

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l i8

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for i16

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l i16

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for i32

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l i32

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for i64

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l i64

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for i128

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l i128

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for isize

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l isize

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for IBig

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l IBig

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<FBig<R, B>> for CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<FBig<R, B>> for &'l CachedFBig<R, B>

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<IBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<IBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<UBig> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: UBig) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<UBig> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: UBig) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<i8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<i8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R: Round, const B: Word> Sub<i16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<i16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R: Round, const B: Word> Sub<i32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<i32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R: Round, const B: Word> Sub<i64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<i64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R: Round, const B: Word> Sub<i128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<i128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<isize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<isize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R: Round, const B: Word> Sub<u8> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<u8> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R: Round, const B: Word> Sub<u16> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<u16> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R: Round, const B: Word> Sub<u32> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<u32> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R: Round, const B: Word> Sub<u64> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<u64> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R: Round, const B: Word> Sub<u128> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> Self::Output

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<u128> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> Self::Output

Performs the - operation.

impl<R: Round, const B: Word> Sub<usize> for FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l, R: Round, const B: Word> Sub<usize> for &'l FBig<R, B>

type Output = FBig<R, B>

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&FBig<R, B>> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&FBig<R, B>> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: &FBig<R, B>)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&IBig> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&UBig> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&i8> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&i16> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&i32> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&i64> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&i128> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&isize> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&u8> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&u16> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&u32> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&u64> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&u128> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<&usize> for FBig<R, B>

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

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<FBig<R, B>> for CachedFBig<R, B>

fn sub_assign(&mut self, rhs: FBig<R, B>)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<IBig> for FBig<R, B>

fn sub_assign(&mut self, rhs: IBig)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<UBig> for FBig<R, B>

fn sub_assign(&mut self, rhs: UBig)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<i8> for FBig<R, B>

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<i16> for FBig<R, B>

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<i32> for FBig<R, B>

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<i64> for FBig<R, B>

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<i128> for FBig<R, B>

fn sub_assign(&mut self, rhs: i128)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<isize> for FBig<R, B>

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<u8> for FBig<R, B>

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<u16> for FBig<R, B>

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<u32> for FBig<R, B>

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<u64> for FBig<R, B>

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<u128> for FBig<R, B>

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl<R: Round, const B: Word> SubAssign<usize> for FBig<R, B>

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, R: Round, const B: Word> Sum<&'a FBig<R, B>> for FBig<R, B>

fn sum<I: Iterator<Item = &'a FBig<R, B>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

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

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> ToSql for FBig<R, 10>

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be converted to the specified Postgres Type.

fn to_sql( &self, ty: &Type, out: &mut BytesMut, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>

Converts the value of self into the binary format of the specified Postgres Type, appending it to out.

fn to_sql_checked( &self, ty: &Type, out: &mut BytesMut, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>

An adaptor method used internally by Rust-Postgres.

fn encode_format(&self, _ty: &Type) -> Format

Specify the encode format

impl<R: Round> ToSql<Numeric, Pg> for FBig<R, 10>

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl<R: Round> ToSql<Numeric, Pg> for FBig<R, 10>

fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> Result

See the trait documentation.

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

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<R: Round, const B: Word> TryFrom<FBig<R, B>> for UBig

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<R: Round, const B: Word> TryFrom<FBig<R, B>> for u8

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<R: Round, const B: Word> TryFrom<FBig<R, B>> for u16

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<R: Round, const B: Word> TryFrom<FBig<R, B>> for u32

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

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<R: Round, const B: Word> TryFrom<FBig<R, B>> for u128

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<R: Round, const B: Word> TryFrom<FBig<R, B>> for usize

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<R: Round, const B: Word> TryFrom<FBig<R, B>> for i8

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<R: Round, const B: Word> TryFrom<FBig<R, B>> for i16

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<R: Round, const B: Word> TryFrom<FBig<R, B>> for i32

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<R: Round, const B: Word> TryFrom<FBig<R, B>> for i64

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<R: Round, const B: Word> TryFrom<FBig<R, B>> for i128

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<R: Round, const B: Word> TryFrom<FBig<R, B>> for isize

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<R: Round> TryFrom<FBig<R>> for f32

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<R: Round> TryFrom<FBig<R>> for f64

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<R: Round> TryFrom<f32> for FBig<R, 2>

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<R: Round> TryFrom<f64> for FBig<R, 2>

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

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

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

Formats the value using the given formatter.

impl<R: Round> UpperHex for FBig<R, 2>

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

Formats the value using the given formatter.

impl<R: Round> UpperHex for FBig<R, 16>

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

Formats the value using the given formatter.

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

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<R: Round, const B: Word> Zeroize for FBig<R, B>

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.