Struct FBig 

pub struct FBig<RoundingMode = Zero, const BASE: u64 = 2>
where
    RoundingMode: Round,
{ /* 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, const B: u64> FBig<R, B>

where R: Round,

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

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) -> Approximation<FBig, Rounding>

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, ) -> Approximation<FBig<R, B>, Rounding>

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>(self) -> FBig<NewR, B>

where NewR: Round,

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: u64>( self, ) -> Approximation<FBig<R, NewB>, Rounding>

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: u64>( self, precision: usize, ) -> Approximation<FBig<R, NewB>, Rounding>

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) -> Approximation<IBig, Rounding>

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) -> Approximation<f32, Rounding>

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) -> Approximation<f64, Rounding>

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

where R: Round,

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

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

Panics

Panics if the precision is unlimited.

impl<R, const B: u64> FBig<R, B>

where R: Round,

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: &FBig<R, B>) -> FBig<R, B>

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

where R: Round,

pub const ZERO: FBig<R, B>

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: FBig<R, B>

FBig with value 1 and unlimited precision

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

pub const NEG_ONE: FBig<R, B>

FBig with value -1 and unlimited precision

pub const INFINITY: FBig<R, B>

FBig instance representing the positive infinity (+∞)

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

pub const NEG_INFINITY: FBig<R, B>

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>) -> FBig<R, B>

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>) -> FBig<R, B>

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) -> FBig<R, B>

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: u128, exponent: isize, min_precision: Option<usize>, ) -> FBig<R, B>

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) -> FBig<R, B>

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

where R: Round,

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

where R: Round,

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

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) -> FBig<R, B>

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

where R: Round,

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

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) -> FBig<R, B>

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) -> (FBig<R, B>, FBig<R, B>)

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) -> FBig<R, B>

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) -> FBig<R, B>

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) -> FBig<R, B>

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) -> FBig<R, B>

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

where R: Round,

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

Calculate the sine of the floating point number.

Panics

Panics if the input is infinite.

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

Calculate the cosine of the floating point number.

Panics

Panics if the input is infinite.

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

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) -> FBig<R, B>

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) -> FBig<R, B>

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) -> FBig<R, B>

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) -> FBig<R, B>

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

pub fn atan2(&self, x: &FBig<R, B>) -> FBig<R, B>

Calculate the arctangent of self / x.

Panics

Panics if both arguments are zero.

impl<R, const B: u64> FBig<R, B>

where R: Round,

pub fn pi(precision: usize) -> FBig<R, B>

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

impl<R, const B: u64> FBig<R, B>

where R: Round,

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

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) -> FBig<R, B>

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

where R: Round,

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

Calculate the square root of the floating point number.

Panics

Panics if the precision is unlimited.

pub fn nth_root(&self, n: usize) -> FBig<R, B>

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

where R: Round,

pub fn hypot(&self, other: &FBig<R, B>) -> FBig<R, B>

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

where R: Round,

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

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) -> (FBig<R, B>, FBig<R, B>)

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) -> FBig<R, B>

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) -> FBig<R, B>

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) -> FBig<R, B>

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) -> FBig<R, B>

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) -> Approximation<FBig<R, B>, Rounding>

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

where R: Round,

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) -> FBig<R, B>

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

where R: Round,

type Output = FBig<R, B>

The type of the absolute value.

fn abs(self) -> <FBig<R, B> as Abs>::Output

Compute the absolute value.

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

where R: Round,

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

Compare the magnitude of self against the magnitude of rhs.

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

where R: Round,

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

Compare the magnitude of self against the magnitude of rhs.

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

where R: Round,

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

Compare the magnitude of self against the magnitude of rhs.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

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

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add( self, rhs: &CachedFBig<R, B>, ) -> <FBig<R, B> as Add<&'r CachedFBig<R, B>>>::Output

Performs the + operation.

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

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add( self, rhs: &CachedFBig<R, B>, ) -> <&'l FBig<R, B> as Add<&'r CachedFBig<R, B>>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &IBig) -> <FBig<R, B> as Add<&'r IBig>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &IBig) -> <&'l FBig<R, B> as Add<&'r IBig>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> <FBig<R, B> as Add<&'r UBig>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> <&'l FBig<R, B> as Add<&'r UBig>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> <FBig<R, B> as Add<&'r i8>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> <&'l FBig<R, B> as Add<&'r i8>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> <FBig<R, B> as Add<&'r i16>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> <&'l FBig<R, B> as Add<&'r i16>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> <FBig<R, B> as Add<&'r i32>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> <&'l FBig<R, B> as Add<&'r i32>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> <FBig<R, B> as Add<&'r i64>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> <&'l FBig<R, B> as Add<&'r i64>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i128) -> <FBig<R, B> as Add<&'r i128>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &i128) -> <&'l FBig<R, B> as Add<&'r i128>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> <FBig<R, B> as Add<&'r isize>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> <&'l FBig<R, B> as Add<&'r isize>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> <FBig<R, B> as Add<&'r u8>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> <&'l FBig<R, B> as Add<&'r u8>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> <FBig<R, B> as Add<&'r u16>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> <&'l FBig<R, B> as Add<&'r u16>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> <FBig<R, B> as Add<&'r u32>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> <&'l FBig<R, B> as Add<&'r u32>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> <FBig<R, B> as Add<&'r u64>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> <&'l FBig<R, B> as Add<&'r u64>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u128) -> <FBig<R, B> as Add<&'r u128>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &u128) -> <&'l FBig<R, B> as Add<&'r u128>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> <FBig<R, B> as Add<&'r usize>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> <&'l FBig<R, B> as Add<&'r usize>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

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

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add( self, rhs: CachedFBig<R, B>, ) -> <FBig<R, B> as Add<CachedFBig<R, B>>>::Output

Performs the + operation.

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

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the + operator.

fn add( self, rhs: CachedFBig<R, B>, ) -> <&'l FBig<R, B> as Add<CachedFBig<R, B>>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

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

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: IBig) -> <FBig<R, B> as Add<IBig>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: IBig) -> <&'l FBig<R, B> as Add<IBig>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: UBig) -> <FBig<R, B> as Add<UBig>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: UBig) -> <&'l FBig<R, B> as Add<UBig>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> <FBig<R, B> as Add<i8>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> <&'l FBig<R, B> as Add<i8>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> <FBig<R, B> as Add<i16>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> <&'l FBig<R, B> as Add<i16>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> <FBig<R, B> as Add<i32>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> <&'l FBig<R, B> as Add<i32>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> <FBig<R, B> as Add<i64>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> <&'l FBig<R, B> as Add<i64>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i128) -> <FBig<R, B> as Add<i128>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: i128) -> <&'l FBig<R, B> as Add<i128>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> <FBig<R, B> as Add<isize>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> <&'l FBig<R, B> as Add<isize>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> <FBig<R, B> as Add<u8>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> <&'l FBig<R, B> as Add<u8>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> <FBig<R, B> as Add<u16>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> <&'l FBig<R, B> as Add<u16>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> <FBig<R, B> as Add<u32>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> <&'l FBig<R, B> as Add<u32>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> <FBig<R, B> as Add<u64>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> <&'l FBig<R, B> as Add<u64>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> <FBig<R, B> as Add<u128>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> <&'l FBig<R, B> as Add<u128>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> <FBig<R, B> as Add<usize>>::Output

Performs the + operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> <&'l FBig<R, B> as Add<usize>>::Output

Performs the + operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

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

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: IBig)

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: UBig)

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: i128)

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

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

where R: Round,

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl<R> Binary for FBig<R>

where R: Round,

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

Formats the value using the given formatter.

impl<R, const B: u64> Clone for FBig<R, B>

where R: Round,

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

Returns a duplicate of the value.

fn clone_from(&mut self, source: &FBig<R, B>)

Performs copy-assignment from source.

impl<R, const B: u64> CubicRoot for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The type of the cubic root.

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

Compute the cubic root, rounded towards zero by default.

impl<R, const B: u64> Debug for FBig<R, B>

where R: Round,

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

Formats the value using the given formatter.

impl<R, const B: u64> Default for FBig<R, B>

where R: Round,

fn default() -> FBig<R, B>

Default value: 0.

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

where R: Round,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R, const B: u64> Display for FBig<R, B>

where R: Round,

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

Formats the value using the given formatter.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = CachedCBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = CachedCBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

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

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div( self, rhs: &CachedFBig<R, B>, ) -> <FBig<R, B> as Div<&'r CachedFBig<R, B>>>::Output

Performs the / operation.

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

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div( self, rhs: &CachedFBig<R, B>, ) -> <&'l FBig<R, B> as Div<&'r CachedFBig<R, B>>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &FBig<R, B>) -> <FBig<R, B> as Div<&'r FBig<R, B>>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div( self, rhs: &FBig<R, B>, ) -> <&'l FBig<R, B> as Div<&'r FBig<R, B>>>::Output

Performs the / operation.

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

type Output = CachedCBig<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 CachedCBig<R, B>

type Output = CachedCBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &IBig) -> <FBig<R, B> as Div<&'r IBig>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &IBig) -> <&'l FBig<R, B> as Div<&'r IBig>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &UBig) -> <FBig<R, B> as Div<&'r UBig>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &UBig) -> <&'l FBig<R, B> as Div<&'r UBig>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> <FBig<R, B> as Div<&'r i8>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> <&'l FBig<R, B> as Div<&'r i8>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> <FBig<R, B> as Div<&'r i16>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> <&'l FBig<R, B> as Div<&'r i16>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> <FBig<R, B> as Div<&'r i32>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> <&'l FBig<R, B> as Div<&'r i32>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> <FBig<R, B> as Div<&'r i64>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> <&'l FBig<R, B> as Div<&'r i64>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i128) -> <FBig<R, B> as Div<&'r i128>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &i128) -> <&'l FBig<R, B> as Div<&'r i128>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> <FBig<R, B> as Div<&'r isize>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> <&'l FBig<R, B> as Div<&'r isize>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> <FBig<R, B> as Div<&'r u8>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> <&'l FBig<R, B> as Div<&'r u8>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> <FBig<R, B> as Div<&'r u16>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> <&'l FBig<R, B> as Div<&'r u16>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> <FBig<R, B> as Div<&'r u32>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> <&'l FBig<R, B> as Div<&'r u32>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> <FBig<R, B> as Div<&'r u64>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> <&'l FBig<R, B> as Div<&'r u64>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u128) -> <FBig<R, B> as Div<&'r u128>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &u128) -> <&'l FBig<R, B> as Div<&'r u128>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> <FBig<R, B> as Div<&'r usize>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> <&'l FBig<R, B> as Div<&'r usize>>::Output

Performs the / operation.

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

type Output = CBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CBig<R, B>) -> CBig<R, B>

Performs the / operation.

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

type Output = CBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: &CBig<R, B>) -> CBig<R, B>

Performs the / operation.

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

type Output = CBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = CBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = CBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CBig<R, B>) -> CBig<R, B>

Performs the / operation.

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

type Output = CBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: CBig<R, B>) -> CBig<R, B>

Performs the / operation.

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

type Output = CachedCBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = CachedCBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

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

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div( self, rhs: CachedFBig<R, B>, ) -> <FBig<R, B> as Div<CachedFBig<R, B>>>::Output

Performs the / operation.

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

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the / operator.

fn div( self, rhs: CachedFBig<R, B>, ) -> <&'l FBig<R, B> as Div<CachedFBig<R, B>>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: FBig<R, B>) -> <&'l FBig<R, B> as Div<FBig<R, B>>>::Output

Performs the / operation.

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

type Output = CachedCBig<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 CachedCBig<R, B>

type Output = CachedCBig<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 &CBig<R, B>

type Output = CBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = CBig<R, B>

The resulting type after applying the / operator.

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

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: IBig) -> <FBig<R, B> as Div<IBig>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: IBig) -> <&'l FBig<R, B> as Div<IBig>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: UBig) -> <FBig<R, B> as Div<UBig>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: UBig) -> <&'l FBig<R, B> as Div<UBig>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> <FBig<R, B> as Div<i8>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> <&'l FBig<R, B> as Div<i8>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> <FBig<R, B> as Div<i16>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> <&'l FBig<R, B> as Div<i16>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> <FBig<R, B> as Div<i32>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> <&'l FBig<R, B> as Div<i32>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> <FBig<R, B> as Div<i64>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> <&'l FBig<R, B> as Div<i64>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> <FBig<R, B> as Div<i128>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> <&'l FBig<R, B> as Div<i128>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> <FBig<R, B> as Div<isize>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> <&'l FBig<R, B> as Div<isize>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> <FBig<R, B> as Div<u8>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> <&'l FBig<R, B> as Div<u8>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> <FBig<R, B> as Div<u16>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> <&'l FBig<R, B> as Div<u16>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> <FBig<R, B> as Div<u32>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> <&'l FBig<R, B> as Div<u32>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> <FBig<R, B> as Div<u64>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> <&'l FBig<R, B> as Div<u64>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> <FBig<R, B> as Div<u128>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> <&'l FBig<R, B> as Div<u128>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> <FBig<R, B> as Div<usize>>::Output

Performs the / operation.

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

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> <&'l FBig<R, B> as Div<usize>>::Output

Performs the / operation.

impl<R, const B: u64> DivAssign for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&FBig<R, B>> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&IBig> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&UBig> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&i8> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&i16> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&i32> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&i64> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&i128> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&isize> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&u8> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&u16> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&u32> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&u64> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&u128> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<&usize> for FBig<R, B>

where R: Round,

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

Performs the /= operation.

impl<R, const B: u64> DivAssign<IBig> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: IBig)

Performs the /= operation.

impl<R, const B: u64> DivAssign<UBig> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: UBig)

Performs the /= operation.

impl<R, const B: u64> DivAssign<i8> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<R, const B: u64> DivAssign<i16> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<R, const B: u64> DivAssign<i32> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<R, const B: u64> DivAssign<i64> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<R, const B: u64> DivAssign<i128> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl<R, const B: u64> DivAssign<isize> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl<R, const B: u64> DivAssign<u8> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<R, const B: u64> DivAssign<u16> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<R, const B: u64> DivAssign<u32> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<R, const B: u64> DivAssign<u64> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<R, const B: u64> DivAssign<u128> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: u128)

Performs the /= operation.

impl<R, const B: u64> DivAssign<usize> for FBig<R, B>

where R: Round,

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl<R, const B: u64> DivEuclid for FBig<R, B>

where R: Round,

type Output = IBig

The type of the quotient.

fn div_euclid(self, rhs: FBig<R, B>) -> <FBig<R, B> as DivEuclid>::Output

Compute the Euclidean quotient of self / rhs.

impl<R, const B: u64> DivEuclid<&FBig<R, B>> for FBig<R, B>

where R: Round,

type Output = IBig

The type of the quotient.

fn div_euclid( self, rhs: &FBig<R, B>, ) -> <FBig<R, B> as DivEuclid<&FBig<R, B>>>::Output

Compute the Euclidean quotient of self / rhs.

impl<R, const B: u64> DivEuclid<&FBig<R, B>> for &FBig<R, B>

where R: Round,

type Output = IBig

The type of the quotient.

fn div_euclid( self, rhs: &FBig<R, B>, ) -> <&FBig<R, B> as DivEuclid<&FBig<R, B>>>::Output

Compute the Euclidean quotient of self / rhs.

impl<R, const B: u64> DivEuclid<FBig<R, B>> for &FBig<R, B>

where R: Round,

type Output = IBig

The type of the quotient.

fn div_euclid( self, rhs: FBig<R, B>, ) -> <&FBig<R, B> as DivEuclid<FBig<R, B>>>::Output

Compute the Euclidean quotient of self / rhs.

impl<R, const B: u64> DivRemEuclid for FBig<R, B>

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

impl<R, const B: u64> EstimatedLog2 for FBig<R, B>

where R: Round,

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

where R: Round,

fn div_euclid(&self, v: &FBig<R, B>) -> FBig<R, B>

Calculates Euclidean division, the matching method for rem_euclid.

fn rem_euclid(&self, v: &FBig<R, B>) -> FBig<R, B>

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

where R: Round,

fn from(cached: CachedFBig<R, B>) -> FBig<R, B>

Converts to this type from the input type.

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

fn from(re: FBig<R, B>) -> Self

Converts to this type from the input type.

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

fn from(re: FBig<R, B>) -> Self

Embed a real FBig as a complex number with imaginary part +0.

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

where R: Round,

fn from(n: IBig) -> FBig<R, B>

Converts to this type from the input type.

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

where R: Round,

fn from(n: UBig) -> FBig<R, B>

Converts to this type from the input type.

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

where R: Round,

fn from(value: i8) -> FBig<R, B>

Converts to this type from the input type.

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

where R: Round,

fn from(value: i16) -> FBig<R, B>

Converts to this type from the input type.

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

where R: Round,

fn from(value: i32) -> FBig<R, B>

Converts to this type from the input type.

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

where R: Round,

fn from(value: i64) -> FBig<R, B>

Converts to this type from the input type.

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

where R: Round,

fn from(value: i128) -> FBig<R, B>

Converts to this type from the input type.

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

where R: Round,

fn from(value: isize) -> FBig<R, B>

Converts to this type from the input type.

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

where R: Round,

fn from(value: u8) -> FBig<R, B>

Converts to this type from the input type.

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

where R: Round,

fn from(value: u16) -> FBig<R, B>

Converts to this type from the input type.

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

where R: Round,

fn from(value: u32) -> FBig<R, B>

Converts to this type from the input type.

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

where R: Round,

fn from(value: u64) -> FBig<R, B>

Converts to this type from the input type.

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

where R: Round,

fn from(value: u128) -> FBig<R, B>

Converts to this type from the input type.

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

where R: Round,

fn from(value: usize) -> FBig<R, B>

Converts to this type from the input type.

impl<R, const B: u64> FromPrimitive for FBig<R, B>

where R: Round,

fn from_i8(n: i8) -> Option<FBig<R, B>>

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<FBig<R, B>>

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<FBig<R, B>>

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<FBig<R, B>>

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<FBig<R, B>>

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<FBig<R, B>>

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<FBig<R, B>>

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<FBig<R, B>>

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<FBig<R, B>>

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<FBig<R, B>>

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<FBig<R, B>>

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<FBig<R, B>>

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<FBig<R, B>>

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<FBig<R, B>>

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

where R: Round,

fn from_str(s: &str) -> Result<FBig<R, B>, 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, const B: u64> Inverse for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The type of the reciprocal.

fn inv(self) -> <FBig<R, B> as Inverse>::Output

Compute the multiplicative inverse (reciprocal) of the number.

impl<R, const B: u64> Inverse for &FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The type of the reciprocal.

fn inv(self) -> <&FBig<R, B> as Inverse>::Output

Compute the multiplicative inverse (reciprocal) of the number.

impl<R, const B: u64> LowerExp for FBig<R, B>

where R: Round,

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

Formats the value using the given formatter.

impl<R> LowerHex for FBig<R>

where R: Round,

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

Formats the value using the given formatter.

impl<R> LowerHex for FBig<R, 16>

where R: Round,

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

Formats the value using the given formatter.

impl<R, const B: u64> Mul for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> <FBig<R, B> as Mul>::Output

Performs the * operation.

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

type Output = CachedCBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedCBig<R, B>) -> Self::Output

Performs the * operation.

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

type Output = CachedCBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CachedCBig<R, B>) -> Self::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r CachedFBig<R, B>> for FBig<R, B>

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul( self, rhs: &CachedFBig<R, B>, ) -> <FBig<R, B> as Mul<&'r CachedFBig<R, B>>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r CachedFBig<R, B>> for &'l FBig<R, B>

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul( self, rhs: &CachedFBig<R, B>, ) -> <&'l FBig<R, B> as Mul<&'r CachedFBig<R, B>>>::Output

Performs the * operation.

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

type Output = CachedCBig<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 CachedCBig<R, B>

type Output = CachedCBig<R, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r IBig> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> <FBig<R, B> as Mul<&'r IBig>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r IBig> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> <&'l FBig<R, B> as Mul<&'r IBig>>::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r UBig> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> <FBig<R, B> as Mul<&'r UBig>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r UBig> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> <&'l FBig<R, B> as Mul<&'r UBig>>::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r i8> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> <FBig<R, B> as Mul<&'r i8>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r i8> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> <&'l FBig<R, B> as Mul<&'r i8>>::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r i16> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> <FBig<R, B> as Mul<&'r i16>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r i16> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> <&'l FBig<R, B> as Mul<&'r i16>>::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r i32> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> <FBig<R, B> as Mul<&'r i32>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r i32> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> <&'l FBig<R, B> as Mul<&'r i32>>::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r i64> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> <FBig<R, B> as Mul<&'r i64>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r i64> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> <&'l FBig<R, B> as Mul<&'r i64>>::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r i128> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i128) -> <FBig<R, B> as Mul<&'r i128>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r i128> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &i128) -> <&'l FBig<R, B> as Mul<&'r i128>>::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r isize> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> <FBig<R, B> as Mul<&'r isize>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r isize> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> <&'l FBig<R, B> as Mul<&'r isize>>::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r u8> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> <FBig<R, B> as Mul<&'r u8>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r u8> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> <&'l FBig<R, B> as Mul<&'r u8>>::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r u16> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> <FBig<R, B> as Mul<&'r u16>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r u16> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> <&'l FBig<R, B> as Mul<&'r u16>>::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r u32> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> <FBig<R, B> as Mul<&'r u32>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r u32> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> <&'l FBig<R, B> as Mul<&'r u32>>::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r u64> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> <FBig<R, B> as Mul<&'r u64>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r u64> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> <&'l FBig<R, B> as Mul<&'r u64>>::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r u128> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u128) -> <FBig<R, B> as Mul<&'r u128>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r u128> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &u128) -> <&'l FBig<R, B> as Mul<&'r u128>>::Output

Performs the * operation.

impl<'r, R, const B: u64> Mul<&'r usize> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> <FBig<R, B> as Mul<&'r usize>>::Output

Performs the * operation.

impl<'l, 'r, R, const B: u64> Mul<&'r usize> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> <&'l FBig<R, B> as Mul<&'r usize>>::Output

Performs the * operation.

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

type Output = CBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CBig<R, B>) -> CBig<R, B>

Performs the * operation.

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

type Output = CBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &CBig<R, B>) -> CBig<R, B>

Performs the * operation.

impl<R, const B: u64> Mul<&FBig<R, B>> for &FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> <&FBig<R, B> as Mul<&FBig<R, B>>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<&FBig<R, B>> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> <FBig<R, B> as Mul<&FBig<R, B>>>::Output

Performs the * operation.

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

type Output = CBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> CBig<R, B>

Performs the * operation.

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

type Output = CBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: &FBig<R, B>) -> CBig<R, B>

Performs the * operation.

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

type Output = CBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CBig<R, B>) -> CBig<R, B>

Performs the * operation.

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

type Output = CBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CBig<R, B>) -> CBig<R, B>

Performs the * operation.

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

type Output = CachedCBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedCBig<R, B>) -> Self::Output

Performs the * operation.

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

type Output = CachedCBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: CachedCBig<R, B>) -> Self::Output

Performs the * operation.

impl<R, const B: u64> Mul<CachedFBig<R, B>> for FBig<R, B>

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul( self, rhs: CachedFBig<R, B>, ) -> <FBig<R, B> as Mul<CachedFBig<R, B>>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<CachedFBig<R, B>> for &'l FBig<R, B>

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the * operator.

fn mul( self, rhs: CachedFBig<R, B>, ) -> <&'l FBig<R, B> as Mul<CachedFBig<R, B>>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<FBig<R, B>> for &FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> <&FBig<R, B> as Mul<FBig<R, B>>>::Output

Performs the * operation.

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

type Output = CachedCBig<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 CachedCBig<R, B>

type Output = CachedCBig<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 &CBig<R, B>

type Output = CBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> CBig<R, B>

Performs the * operation.

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

type Output = CBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: FBig<R, B>) -> CBig<R, B>

Performs the * operation.

impl<R, const B: u64> Mul<IBig> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> <FBig<R, B> as Mul<IBig>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<IBig> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> <&'l FBig<R, B> as Mul<IBig>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<Sign> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: Sign) -> <FBig<R, B> as Mul<Sign>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<UBig> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: UBig) -> <FBig<R, B> as Mul<UBig>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<UBig> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: UBig) -> <&'l FBig<R, B> as Mul<UBig>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<i8> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> <FBig<R, B> as Mul<i8>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<i8> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> <&'l FBig<R, B> as Mul<i8>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<i16> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> <FBig<R, B> as Mul<i16>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<i16> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> <&'l FBig<R, B> as Mul<i16>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<i32> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> <FBig<R, B> as Mul<i32>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<i32> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> <&'l FBig<R, B> as Mul<i32>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<i64> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> <FBig<R, B> as Mul<i64>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<i64> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> <&'l FBig<R, B> as Mul<i64>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<i128> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> <FBig<R, B> as Mul<i128>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<i128> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> <&'l FBig<R, B> as Mul<i128>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<isize> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> <FBig<R, B> as Mul<isize>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<isize> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> <&'l FBig<R, B> as Mul<isize>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<u8> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> <FBig<R, B> as Mul<u8>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<u8> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> <&'l FBig<R, B> as Mul<u8>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<u16> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> <FBig<R, B> as Mul<u16>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<u16> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> <&'l FBig<R, B> as Mul<u16>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<u32> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> <FBig<R, B> as Mul<u32>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<u32> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> <&'l FBig<R, B> as Mul<u32>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<u64> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> <FBig<R, B> as Mul<u64>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<u64> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> <&'l FBig<R, B> as Mul<u64>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<u128> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> <FBig<R, B> as Mul<u128>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<u128> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> <&'l FBig<R, B> as Mul<u128>>::Output

Performs the * operation.

impl<R, const B: u64> Mul<usize> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> <FBig<R, B> as Mul<usize>>::Output

Performs the * operation.

impl<'l, R, const B: u64> Mul<usize> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> <&'l FBig<R, B> as Mul<usize>>::Output

Performs the * operation.

impl<R, const B: u64> MulAssign for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&FBig<R, B>> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&IBig> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&UBig> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&i8> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&i16> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&i32> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&i64> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&i128> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&isize> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&u8> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&u16> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&u32> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&u64> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&u128> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<&usize> for FBig<R, B>

where R: Round,

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

Performs the *= operation.

impl<R, const B: u64> MulAssign<IBig> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: IBig)

Performs the *= operation.

impl<R, const B: u64> MulAssign<Sign> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: Sign)

Performs the *= operation.

impl<R, const B: u64> MulAssign<UBig> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: UBig)

Performs the *= operation.

impl<R, const B: u64> MulAssign<i8> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<R, const B: u64> MulAssign<i16> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<R, const B: u64> MulAssign<i32> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<R, const B: u64> MulAssign<i64> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<R, const B: u64> MulAssign<i128> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl<R, const B: u64> MulAssign<isize> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: isize)

Performs the *= operation.

impl<R, const B: u64> MulAssign<u8> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<R, const B: u64> MulAssign<u16> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<R, const B: u64> MulAssign<u32> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<R, const B: u64> MulAssign<u64> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<R, const B: u64> MulAssign<u128> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: u128)

Performs the *= operation.

impl<R, const B: u64> MulAssign<usize> for FBig<R, B>

where R: Round,

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl<R, const B: u64> Neg for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn neg(self) -> <FBig<R, B> as Neg>::Output

Performs the unary - operation.

impl<R, const B: u64> Neg for &FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn neg(self) -> <&FBig<R, B> as Neg>::Output

Performs the unary - operation.

impl<R, const B: u64> Num for FBig<R, B>

where R: Round,

type FromStrRadixErr = ParseError

fn from_str_radix( s: &str, radix: u32, ) -> Result<FBig<R, B>, <FBig<R, B> as Num>::FromStrRadixErr>

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

impl<R, const B: u64> NumHash for FBig<R, B>

where R: Round,

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

where H: Hasher,

Consistent Hash::hash on different numeric types.

impl<R1, R2, const B1: u64, const B2: u64> NumOrd<FBig<R2, B2>> for FBig<R1, B1>

where R1: Round, R2: Round,

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

where R: Round,

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

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

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

PartialOrd::partial_cmp on different numeric types

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

PartialEq::eq on different numeric types

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

PartialEq::ne on different numeric types

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

PartialOrd::lt on different numeric types

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

PartialOrd::le on different numeric types

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

PartialOrd::gt on different numeric types

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

PartialOrd::ge on different numeric types

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

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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> Octal for FBig<R, 8>

where R: Round,

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

Formats the value using the given formatter.

impl<R, const B: u64> One for FBig<R, B>

where R: Round,

fn one() -> FBig<R, B>

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

where R: Round,

fn cmp(&self, other: &FBig<R, B>) -> 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, R2, const B: u64> PartialEq<FBig<R2, B>> for FBig<R1, B>

where R1: Round, R2: Round,

fn eq(&self, other: &FBig<R2, B>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<R1, R2, const B: u64> PartialOrd<FBig<R2, B>> for FBig<R1, B>

where R1: Round, R2: Round,

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

where R: Round,

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

where R: Round,

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

where R: Round,

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, const B: u64> Pow<IBig> for &FBig<R, B>

where R: Round,

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

where R: Round,

fn product<I>(iter: I) -> FBig<R, B>

where I: Iterator<Item = FBig<R, B>>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, R, const B: u64> Product<&'a FBig<R, B>> for FBig<R, B>

where R: Round,

fn product<I>(iter: I) -> FBig<R, B>

where I: Iterator<Item = &'a FBig<R, B>>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<R, const B: u64> Rem for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: FBig<R, B>) -> <FBig<R, B> as Rem>::Output

Performs the % operation.

impl<'r, R, const B: u64> Rem<&'r CachedFBig<R, B>> for FBig<R, B>

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem( self, rhs: &CachedFBig<R, B>, ) -> <FBig<R, B> as Rem<&'r CachedFBig<R, B>>>::Output

Performs the % operation.

impl<'l, 'r, R, const B: u64> Rem<&'r CachedFBig<R, B>> for &'l FBig<R, B>

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem( self, rhs: &CachedFBig<R, B>, ) -> <&'l FBig<R, B> as Rem<&'r CachedFBig<R, B>>>::Output

Performs the % operation.

impl<'r, R, const B: u64> Rem<&'r FBig<R, B>> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: &FBig<R, B>) -> <FBig<R, B> as Rem<&'r FBig<R, B>>>::Output

Performs the % operation.

impl<'l, 'r, R, const B: u64> Rem<&'r FBig<R, B>> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the % operator.

fn rem( self, rhs: &FBig<R, B>, ) -> <&'l FBig<R, B> as Rem<&'r FBig<R, B>>>::Output

Performs the % operation.

impl<R, const B: u64> Rem<CachedFBig<R, B>> for FBig<R, B>

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem( self, rhs: CachedFBig<R, B>, ) -> <FBig<R, B> as Rem<CachedFBig<R, B>>>::Output

Performs the % operation.

impl<'l, R, const B: u64> Rem<CachedFBig<R, B>> for &'l FBig<R, B>

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the % operator.

fn rem( self, rhs: CachedFBig<R, B>, ) -> <&'l FBig<R, B> as Rem<CachedFBig<R, B>>>::Output

Performs the % operation.

impl<'l, R, const B: u64> Rem<FBig<R, B>> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the % operator.

fn rem(self, rhs: FBig<R, B>) -> <&'l FBig<R, B> as Rem<FBig<R, B>>>::Output

Performs the % operation.

impl<R, const B: u64> RemAssign for FBig<R, B>

where R: Round,

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

Performs the %= operation.

impl<R, const B: u64> RemAssign<&FBig<R, B>> for FBig<R, B>

where R: Round,

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

Performs the %= operation.

impl<R, const B: u64> RemEuclid for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The type of the remainder.

fn rem_euclid(self, rhs: FBig<R, B>) -> <FBig<R, B> as RemEuclid>::Output

Compute the non-negative Euclidean remainder of self % rhs.

impl<R, const B: u64> RemEuclid<&FBig<R, B>> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The type of the remainder.

fn rem_euclid( self, rhs: &FBig<R, B>, ) -> <FBig<R, B> as RemEuclid<&FBig<R, B>>>::Output

Compute the non-negative Euclidean remainder of self % rhs.

impl<R, const B: u64> RemEuclid<&FBig<R, B>> for &FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The type of the remainder.

fn rem_euclid( self, rhs: &FBig<R, B>, ) -> <&FBig<R, B> as RemEuclid<&FBig<R, B>>>::Output

Compute the non-negative Euclidean remainder of self % rhs.

impl<R, const B: u64> RemEuclid<FBig<R, B>> for &FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The type of the remainder.

fn rem_euclid( self, rhs: FBig<R, B>, ) -> <&FBig<R, B> as RemEuclid<FBig<R, B>>>::Output

Compute the non-negative Euclidean remainder of self % rhs.

impl<R, const B: u64> SampleUniform for FBig<R, B>

where R: Round,

type Sampler = UniformFBig<R, B>

The UniformSampler implementation supporting type X.

impl<R, const B: u64> SampleUniform for FBig<R, B>

where R: Round,

type Sampler = UniformFBig<R, B>

The UniformSampler implementation supporting type X.

impl<R, const B: u64> SampleUniform for FBig<R, B>

where R: Round,

type Sampler = UniformFBig<R, B>

The UniformSampler implementation supporting type X.

impl<R, const B: u64> Serialize for FBig<R, B>

where R: Round,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<R, const B: u64> Shl<isize> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> <FBig<R, B> as Shl<isize>>::Output

Performs the << operation.

impl<R, const B: u64> ShlAssign<isize> for FBig<R, B>

where R: Round,

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation.

impl<R, const B: u64> Shr<isize> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> <FBig<R, B> as Shr<isize>>::Output

Performs the >> operation.

impl<R, const B: u64> ShrAssign<isize> for FBig<R, B>

where R: Round,

fn shr_assign(&mut self, rhs: isize)

Performs the >>= operation.

impl<R, const B: u64> Signed for FBig<R, B>

where R: Round,

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

where R: Round,

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

Computes the absolute value.

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

The positive difference of two numbers.

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

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

where R: Round,

type Output = FBig<R, B>

The type of the square root.

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

Compute the square root, rounded towards zero by default.

impl<R, const B: u64> Sub for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> <FBig<R, B> as Sub>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r CachedFBig<R, B>> for FBig<R, B>

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub( self, rhs: &CachedFBig<R, B>, ) -> <FBig<R, B> as Sub<&'r CachedFBig<R, B>>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r CachedFBig<R, B>> for &'l FBig<R, B>

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub( self, rhs: &CachedFBig<R, B>, ) -> <&'l FBig<R, B> as Sub<&'r CachedFBig<R, B>>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r IBig> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> <FBig<R, B> as Sub<&'r IBig>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r IBig> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> <&'l FBig<R, B> as Sub<&'r IBig>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r UBig> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> <FBig<R, B> as Sub<&'r UBig>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r UBig> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> <&'l FBig<R, B> as Sub<&'r UBig>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r i8> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> <FBig<R, B> as Sub<&'r i8>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r i8> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> <&'l FBig<R, B> as Sub<&'r i8>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r i16> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> <FBig<R, B> as Sub<&'r i16>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r i16> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> <&'l FBig<R, B> as Sub<&'r i16>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r i32> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> <FBig<R, B> as Sub<&'r i32>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r i32> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> <&'l FBig<R, B> as Sub<&'r i32>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r i64> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> <FBig<R, B> as Sub<&'r i64>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r i64> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> <&'l FBig<R, B> as Sub<&'r i64>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r i128> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> <FBig<R, B> as Sub<&'r i128>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r i128> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> <&'l FBig<R, B> as Sub<&'r i128>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r isize> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> <FBig<R, B> as Sub<&'r isize>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r isize> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> <&'l FBig<R, B> as Sub<&'r isize>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r u8> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> <FBig<R, B> as Sub<&'r u8>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r u8> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> <&'l FBig<R, B> as Sub<&'r u8>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r u16> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> <FBig<R, B> as Sub<&'r u16>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r u16> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> <&'l FBig<R, B> as Sub<&'r u16>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r u32> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> <FBig<R, B> as Sub<&'r u32>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r u32> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> <&'l FBig<R, B> as Sub<&'r u32>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r u64> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> <FBig<R, B> as Sub<&'r u64>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r u64> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> <&'l FBig<R, B> as Sub<&'r u64>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r u128> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> <FBig<R, B> as Sub<&'r u128>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r u128> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> <&'l FBig<R, B> as Sub<&'r u128>>::Output

Performs the - operation.

impl<'r, R, const B: u64> Sub<&'r usize> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> <FBig<R, B> as Sub<&'r usize>>::Output

Performs the - operation.

impl<'l, 'r, R, const B: u64> Sub<&'r usize> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> <&'l FBig<R, B> as Sub<&'r usize>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<&FBig<R, B>> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> <FBig<R, B> as Sub<&FBig<R, B>>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<&FBig<R, B>> for &FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: &FBig<R, B>) -> <&FBig<R, B> as Sub<&FBig<R, B>>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<CachedFBig<R, B>> for FBig<R, B>

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub( self, rhs: CachedFBig<R, B>, ) -> <FBig<R, B> as Sub<CachedFBig<R, B>>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<CachedFBig<R, B>> for &'l FBig<R, B>

where R: Round,

type Output = CachedFBig<R, B>

The resulting type after applying the - operator.

fn sub( self, rhs: CachedFBig<R, B>, ) -> <&'l FBig<R, B> as Sub<CachedFBig<R, B>>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<FBig<R, B>> for &FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: FBig<R, B>) -> <&FBig<R, B> as Sub<FBig<R, B>>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<IBig> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> <FBig<R, B> as Sub<IBig>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<IBig> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> <&'l FBig<R, B> as Sub<IBig>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<UBig> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: UBig) -> <FBig<R, B> as Sub<UBig>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<UBig> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: UBig) -> <&'l FBig<R, B> as Sub<UBig>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<i8> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> <FBig<R, B> as Sub<i8>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<i8> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> <&'l FBig<R, B> as Sub<i8>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<i16> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> <FBig<R, B> as Sub<i16>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<i16> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> <&'l FBig<R, B> as Sub<i16>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<i32> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> <FBig<R, B> as Sub<i32>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<i32> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> <&'l FBig<R, B> as Sub<i32>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<i64> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> <FBig<R, B> as Sub<i64>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<i64> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> <&'l FBig<R, B> as Sub<i64>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<i128> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> <FBig<R, B> as Sub<i128>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<i128> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> <&'l FBig<R, B> as Sub<i128>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<isize> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> <FBig<R, B> as Sub<isize>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<isize> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> <&'l FBig<R, B> as Sub<isize>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<u8> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> <FBig<R, B> as Sub<u8>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<u8> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> <&'l FBig<R, B> as Sub<u8>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<u16> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> <FBig<R, B> as Sub<u16>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<u16> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> <&'l FBig<R, B> as Sub<u16>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<u32> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> <FBig<R, B> as Sub<u32>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<u32> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> <&'l FBig<R, B> as Sub<u32>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<u64> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> <FBig<R, B> as Sub<u64>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<u64> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> <&'l FBig<R, B> as Sub<u64>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<u128> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> <FBig<R, B> as Sub<u128>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<u128> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> <&'l FBig<R, B> as Sub<u128>>::Output

Performs the - operation.

impl<R, const B: u64> Sub<usize> for FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> <FBig<R, B> as Sub<usize>>::Output

Performs the - operation.

impl<'l, R, const B: u64> Sub<usize> for &'l FBig<R, B>

where R: Round,

type Output = FBig<R, B>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> <&'l FBig<R, B> as Sub<usize>>::Output

Performs the - operation.

impl<R, const B: u64> SubAssign for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&FBig<R, B>> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&IBig> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&UBig> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&i8> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&i16> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&i32> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&i64> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&i128> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&isize> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&u8> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&u16> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&u32> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&u64> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&u128> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<&usize> for FBig<R, B>

where R: Round,

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

Performs the -= operation.

impl<R, const B: u64> SubAssign<IBig> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: IBig)

Performs the -= operation.

impl<R, const B: u64> SubAssign<UBig> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: UBig)

Performs the -= operation.

impl<R, const B: u64> SubAssign<i8> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<R, const B: u64> SubAssign<i16> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<R, const B: u64> SubAssign<i32> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<R, const B: u64> SubAssign<i64> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<R, const B: u64> SubAssign<i128> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: i128)

Performs the -= operation.

impl<R, const B: u64> SubAssign<isize> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl<R, const B: u64> SubAssign<u8> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<R, const B: u64> SubAssign<u16> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<R, const B: u64> SubAssign<u32> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<R, const B: u64> SubAssign<u64> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<R, const B: u64> SubAssign<u128> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl<R, const B: u64> SubAssign<usize> for FBig<R, B>

where R: Round,

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

impl<R, const B: u64> Sum for FBig<R, B>

where R: Round,

fn sum<I>(iter: I) -> FBig<R, B>

where I: Iterator<Item = FBig<R, B>>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, R, const B: u64> Sum<&'a FBig<R, B>> for FBig<R, B>

where R: Round,

fn sum<I>(iter: I) -> FBig<R, B>

where I: Iterator<Item = &'a FBig<R, B>>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<R, const B: u64> ToPrimitive for FBig<R, B>

where R: Round,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn try_from(z: CBig<R, B>) -> Result<Self, Self::Error>

Extract the real part, succeeding only when the imaginary part is zero (purely real; both ±0 count as zero). This is the guarded “is this complex actually real?” check — distinct from CBig::re / CBig::into_parts, which return the real part unconditionally.

type Error = ConversionError

The type returned in the event of a conversion error.

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

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<R> TryFrom<f32> for FBig<R>

where R: Round,

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(f: f32) -> Result<FBig<R>, <FBig<R> as TryFrom<f32>>::Error>

Performs the conversion.

impl<R> TryFrom<f64> for FBig<R>

where R: Round,

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(f: f64) -> Result<FBig<R>, <FBig<R> as TryFrom<f64>>::Error>

Performs the conversion.

impl<R, const B: u64> UpperExp for FBig<R, B>

where R: Round,

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

Formats the value using the given formatter.

impl<R> UpperHex for FBig<R>

where R: Round,

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

Formats the value using the given formatter.

impl<R> UpperHex for FBig<R, 16>

where R: Round,

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

Formats the value using the given formatter.

impl<R, const B: u64> Zero for FBig<R, B>

where R: Round,

fn zero() -> FBig<R, B>

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

where R: Round,

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.