Struct dashu_float::FBig
source · pub struct FBig<RoundingMode: Round = Zero, const BASE: Word = 2> { /* private fields */ }
Expand description
An arbitrary precision floating point number with arbitrary base and rounding mode.
The float number consists of a Repr and a Context. The Repr instance determines the value of the number, and the Context contains runtime information (such as precision limit, rounding mode, etc.)
For how the number is represented, see Repr, for how the precision limit and rounding mode is applied, see Context.
The arithmetic operations on FBig follows the behavior of its associated context. If a different precision limit and/or rounding mode is required, or the rounding information has to be preserved, use the methods of the Context type.
§Generic Parameters
The const generic parameters will be abbreviated as BASE
-> B
, RoundingMode
-> R
.
THe BASE
must be in range [2, isize::MAX], and the RoundingMode
can be chosen from
the mode module.
With the default generic parameters, the floating number is of base 2 rounded towards zero. This is the most efficient format for operations. To represent a decimal number, the alias DBig is provided, which is base 10 rounded to the nearest.
§Parsing and printing
To create a FBig instance, there are four ways:
- Use predifined constants (e.g. FBig::ZERO, FBig::ONE, FBig::NEG_INFINITY).
- Use the literal macro
fbig!
ordbig!
defined in thedashu-macro
crate. - Construct from the significand and exponent using from_parts() or from_parts_const().
- Parse from a string.
Conversion from and to str is limited to native radix (i.e. base). To print or parse with different radix, please use to_binary(), to_decimal() or with_base(), with_base_and_precision() to convert.
For printing, currently only the Display and Debug are supported. Other formatting traits will be supported in future.
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)"
);
}
For detailed information of parsing, refer to the from_str_native() method.
§Restriction on binary operators
Binary operators on FBig instances are restricted to the same base and same rounding mode. This is designed to make sure that no hidden conversion is performed during the operators. However, for equality test and comparsion, two FBig instances can have different rounding modes (but not different bases), because rounding will never happends during comparison.
The infinities are converted as it is, and the subnormals are converted using its actual values.
§IEEE 754 behavior compliance
The representation of the floating point number doesn’t follows the IEEE 754 standard, as it’s not designed for arbitrary precision numbers. The key differences include:
- FBig doesn’t support NaN values. In places where IEEE 754 operations generate NaNs,
FBig
will panic. - FBig doesn’t have subnormal values.
- FBig doesn’t have negative zeros¹. There is only on zero value (FBig::ZERO).
- Division by zero and logarithm on zero panic instead of returning infinities.
- FBig operations will panic if the result overflows or underflows¹.
- FBig does support infinities, but currently infinities are not allowed to be operated with, except for equality test and comparison¹.
¹ These behaviors are subject to changes in the future.
§Convert from/to f32
/f64
Converting from f32/f64 to FBig is only defined for base 2 FBig (using TryFrom)
to ensure the conversion is lossless. Since FBig doesn’t support NAN
s, converting f32::NAN
or f64::NAN
will
return Err.
Converting to f32/f64 (using to_f32() and to_f64()) can be lossy, and the rounding direction is contained in the result of these two methods. To use the default IEEE 754 rounding mode (rounding to nearest), the Repr::to_f32 and Repr::to_f64 methods can be used for convenience.
§Convert from/to UBig
/IBig
Converting from UBig
and IBig
is trivial and lossless through From. However, the reverse direction can be lossy.
The TryFrom trait and to_int() method are the two supported ways to convert from FBig to IBig. To convert to UBig, please first convert to IBig. When converting to IBig, TryFrom returns Ok only when the floating point number is not infinite and doesn’t have fractional part. To convert with rounding, use to_int() instead.
Implementations§
source§impl<R: Round, const B: Word> FBig<R, B>
impl<R: Round, const B: Word> FBig<R, B>
sourcepub fn to_decimal(&self) -> Rounded<FBig<HalfAway, 10>>
pub fn to_decimal(&self) -> Rounded<FBig<HalfAway, 10>>
Convert the float number to base 10 (with decimal exponents) rounding to even and tying away from zero.
It’s equivalent to self.with_rounding::<HalfAway>().with_base::<10>()
.
The output is directly of type DBig.
See with_base() for the precision behavior.
§Examples
use dashu_base::Approximation::*;
use dashu_float::round::Rounding::*;
type Real = FBig;
assert_eq!(
Real::from_str("0x1234")?.to_decimal(),
Exact(DBig::from_str("4660")?)
);
assert_eq!(
Real::from_str("0x12.34")?.to_decimal(),
Inexact(DBig::from_str("18.20")?, NoOp)
);
assert_eq!(
Real::from_str("0x1.234p-4")?.to_decimal(),
Inexact(DBig::from_str("0.07111")?, AddOne)
);
§Panics
Panics if the associated context has unlimited precision and the conversion cannot be performed losslessly.
sourcepub fn to_binary(&self) -> Rounded<FBig<Zero, 2>>
pub fn to_binary(&self) -> Rounded<FBig<Zero, 2>>
Convert the float number to base 2 (with binary exponents) rounding towards zero.
It’s equivalent to self.with_rounding::<Zero>().with_base::<2>()
.
See with_base() for the precision and rounding behavior.
§Examples
use dashu_base::Approximation::*;
use dashu_float::round::{mode::HalfAway, Rounding::*};
type Real = FBig;
assert_eq!(
DBig::from_str("1234")?.to_binary(),
Exact(Real::from_str("0x4d2")?)
);
assert_eq!(
DBig::from_str("12.34")?.to_binary(),
Inexact(Real::from_str("0xc.57")?, NoOp)
);
assert_eq!(
DBig::from_str("1.234e-1")?.to_binary(),
Inexact(Real::from_str("0x1.f97p-4")?, NoOp)
);
§Panics
Panics if the associated context has unlimited precision and the conversion cannot be performed losslessly.
sourcepub fn with_precision(self, precision: usize) -> Rounded<Self>
pub fn with_precision(self, precision: usize) -> Rounded<Self>
Explicitly change the precision of the float number.
If the given precision is less than the current value in the context, it will be rounded with the rounding mode specified by the generic parameter.
§Examples
use dashu_base::Approximation::*;
use dashu_float::round::{mode::HalfAway, Rounding::*};
let a = DBig::from_str("2.345")?;
assert_eq!(a.precision(), 4);
assert_eq!(
a.clone().with_precision(3),
Inexact(DBig::from_str("2.35")?, AddOne)
);
assert_eq!(
a.clone().with_precision(5),
Exact(DBig::from_str("2.345")?)
);
sourcepub fn with_rounding<NewR: Round>(self) -> FBig<NewR, B>
pub fn with_rounding<NewR: Round>(self) -> FBig<NewR, B>
Explicitly change the rounding mode of the number.
This operation doesn’t modify the underlying representation, it only changes the rounding mode in the context.
§Examples
use dashu_base::Approximation::*;
use dashu_float::round::{mode::{HalfAway, Zero}, Rounding::*};
type DBigHalfAway = DBig;
type DBigZero = FBig::<Zero, 10>;
let a = DBigHalfAway::from_str("2.345")?;
let b = DBigZero::from_str("2.345")?;
assert_eq!(a.with_rounding::<Zero>(), b);
sourcepub fn with_base<const NewB: Word>(self) -> Rounded<FBig<R, NewB>>
pub fn with_base<const NewB: Word>(self) -> Rounded<FBig<R, NewB>>
Explicitly change the base of the float number.
This function internally calls with_base_and_precision. The precision of the result number will be calculated in such a way that the new limit of the significand is less than or equal to before. That is, the new precision will be the max integer such that
NewB ^ new_precision <= B ^ old_precision
If any rounding happens during the conversion, it follows the rounding mode specified by the generic parameter.
§Examples
use dashu_base::Approximation::*;
use dashu_float::round::{mode::Zero, Rounding::*};
type FBin = FBig;
type FDec = FBig<Zero, 10>;
type FHex = FBig<Zero, 16>;
let a = FBin::from_str("0x1.234")?; // 0x1234 * 2^-12
assert_eq!(
a.clone().with_base::<10>(),
// 1.1376953125 rounded towards zero
Inexact(FDec::from_str("1.137")?, NoOp)
);
assert_eq!(
a.clone().with_base::<16>(),
// conversion is exact when the new base is a power of the old base
Exact(FHex::from_str("1.234")?)
);
§Panics
Panics if the associated context has unlimited precision and the conversion cannot be performed losslessly.
sourcepub fn with_base_and_precision<const NewB: Word>(
self,
precision: usize
) -> Rounded<FBig<R, NewB>>
pub fn with_base_and_precision<const NewB: Word>( self, precision: usize ) -> Rounded<FBig<R, NewB>>
Explicitly change the base of the float number with given precision (under the new base).
Infinities are mapped to infinities inexactly, the error will be NoOp.
Conversion for float numbers with unlimited precision is only allowed in following cases:
- The number is infinite
- The new base NewB is a power of B
- B is a power of the new base NewB
§Examples
use dashu_base::Approximation::*;
use dashu_float::round::{mode::Zero, Rounding::*};
type FBin = FBig;
type FDec = FBig<Zero, 10>;
type FHex = FBig<Zero, 16>;
let a = FBin::from_str("0x1.234")?; // 0x1234 * 2^-12
assert_eq!(
a.clone().with_base_and_precision::<10>(8),
// 1.1376953125 rounded towards zero
Inexact(FDec::from_str("1.1376953")?, NoOp)
);
assert_eq!(
a.clone().with_base_and_precision::<16>(8),
// conversion can be exact when the new base is a power of the old base
Exact(FHex::from_str("1.234")?)
);
assert_eq!(
a.clone().with_base_and_precision::<16>(2),
// but the conversion is still inexact if the target precision is smaller
Inexact(FHex::from_str("1.2")?, NoOp)
);
§Panics
Panics if the associated context has unlimited precision and the conversion cannot be performed losslessly.
sourcepub fn to_int(&self) -> Rounded<IBig>
pub fn to_int(&self) -> Rounded<IBig>
Convert the float number to integer with the given rounding mode.
§Warning
If the float number has a very large exponent, it will be evaluated and result in allocating an huge integer and it might eat up all your memory.
To get a rough idea of how big the number is, it’s recommended to use EstimatedLog2.
§Examples
use dashu_base::Approximation::*;
use dashu_float::round::Rounding::*;
assert_eq!(
DBig::from_str("1234")?.to_int(),
Exact(1234.into())
);
assert_eq!(
DBig::from_str("1.234e6")?.to_int(),
Exact(1234000.into())
);
assert_eq!(
DBig::from_str("1.234")?.to_int(),
Inexact(1.into(), NoOp)
);
§Panics
Panics if the number is infinte
sourcepub fn to_f64(&self) -> Rounded<f64>
pub fn to_f64(&self) -> Rounded<f64>
Convert the float number to f64 with HalfEven rounding mode regardless of the mode associated with this number.
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);
source§impl<R: Round, const B: Word> FBig<R, B>
impl<R: Round, const B: Word> FBig<R, B>
sourcepub fn powi(&self, exp: IBig) -> FBig<R, B>
pub fn powi(&self, exp: IBig) -> FBig<R, B>
Raise the floating point number to an integer power.
§Examples
let a = DBig::from_str_native("-1.234")?;
assert_eq!(a.powi(10.into()), DBig::from_str_native("8.188")?);
sourcepub fn powf(&self, exp: &Self) -> Self
pub fn powf(&self, exp: &Self) -> Self
Raise the floating point number to an floating point power.
§Examples
let x = DBig::from_str_native("1.23")?;
let y = DBig::from_str_native("-4.56")?;
assert_eq!(x.powf(&y), DBig::from_str_native("0.389")?);
source§impl<R: Round, const B: Word> FBig<R, B>
impl<R: Round, const B: Word> FBig<R, B>
sourcepub fn from_repr(repr: Repr<B>, context: Context<R>) -> Self
pub fn from_repr(repr: Repr<B>, context: Context<R>) -> Self
Create a FBig instance from Repr and Context.
This method should not be used in most cases. It’s designed to be used when you hold a Repr instance and want to create an FBig from that.
§Examples
use dashu_float::{Repr, Context};
assert_eq!(DBig::from_repr(Repr::one(), Context::new(1)), DBig::ONE);
assert_eq!(DBig::from_repr(Repr::infinity(), Context::new(1)), DBig::INFINITY);
§Panics
Panics if the Repr has more digits than the precision limit specified in the context. Note that this condition is not checked in release builds.
sourcepub const fn from_repr_const(repr: Repr<B>) -> Self
pub const fn from_repr_const(repr: Repr<B>) -> Self
sourcepub const ZERO: Self = _
pub const ZERO: Self = _
FBig with value 0 and unlimited precision
To test if the float number is zero, use self.repr().is_zero()
.
sourcepub const ONE: Self = _
pub const ONE: Self = _
FBig with value 1 and unlimited precision
To test if the float number is one, use self.repr().is_one()
.
sourcepub const INFINITY: Self = _
pub const INFINITY: Self = _
FBig instance representing the positive infinity (+∞)
To test if the float number is infinite, use self.repr().infinite()
.
sourcepub const NEG_INFINITY: Self = _
pub const NEG_INFINITY: Self = _
FBig instance representing the negative infinity (-∞)
To test if the float number is infinite, use self.repr().infinite()
.
sourcepub const fn precision(&self) -> usize
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()));
sourcepub fn digits(&self) -> usize
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(_, _)));
sourcepub fn into_repr(self) -> Repr<B>
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());
sourcepub fn from_parts(significand: IBig, exponent: isize) -> Self
pub fn from_parts(significand: IBig, exponent: isize) -> Self
Convert raw parts (significand, exponent) into a float number.
The precision will be inferred from significand (the lowest k such that significand <= base^k
)
§Examples
use core::str::FromStr;
let a = DBig::from_parts((-1234).into(), -2);
assert_eq!(a, DBig::from_str("-12.34")?);
assert_eq!(a.precision(), 4); // 1234 has 4 (decimal) digits
sourcepub const fn from_parts_const(
sign: Sign,
significand: DoubleWord,
exponent: isize,
min_precision: Option<usize>
) -> Self
pub const fn from_parts_const( sign: Sign, significand: DoubleWord, exponent: isize, min_precision: Option<usize> ) -> Self
Convert raw parts (significand, exponent) into a float number in a const
context.
It requires that the significand fits in a DoubleWord.
The precision will be inferred from significand (the lowest k such that significand <= base^k
).
If the min_precision
is provided, then the higher one from the given and inferred precision
will be used as the final precision.
§Examples
use core::str::FromStr;
use dashu_base::Sign;
const A: DBig = DBig::from_parts_const(Sign::Negative, 1234, -2, None);
assert_eq!(A, DBig::from_str("-12.34")?);
assert_eq!(A.precision(), 4); // 1234 has 4 (decimal) digits
const B: DBig = DBig::from_parts_const(Sign::Negative, 1234, -2, Some(5));
assert_eq!(B.precision(), 5); // overrided by the argument
sourcepub fn ulp(&self) -> Self
pub fn ulp(&self) -> Self
Return the value of the least significant digit of the float number x,
such that x + ulp
is the first float number greater than x (given the precision from the context).
§Examples
assert_eq!(DBig::from_str("1.23")?.ulp(), DBig::from_str("0.01")?);
assert_eq!(DBig::from_str("01.23")?.ulp(), DBig::from_str("0.001")?);
§Panics
Panics if the precision of the number is 0 (unlimited).
source§impl<R: Round, const B: Word> FBig<R, B>
impl<R: Round, const B: Word> FBig<R, B>
source§impl<R: Round, const B: Word> FBig<R, B>
impl<R: Round, const B: Word> FBig<R, B>
source§impl<R: Round, const B: Word> FBig<R, B>
impl<R: Round, const B: Word> FBig<R, B>
sourcepub fn from_str_native(src: &str) -> Result<Self, ParseError>
👎Deprecated since 0.5.0: from_str_native will be removed in v0.5. Use core::str::FromStr instead.
pub fn from_str_native(src: &str) -> Result<Self, ParseError>
Convert a string in the native base (i.e. radix B
) to FBig.
If the parsing succeeded, the result number will be losslessly parsed from the input string.
This function is the actual implementation of the FromStr trait.
Note: Infinites are intentionally not supported by this function.
§Format
The valid representations include
aaa
oraaa.
aaa
is represented in native baseB
without base prefixes.
aaa.bbb
=aaabbb / base ^ len(bbb)
aaa
andbbb
are represented in native baseB
without base prefixes.len(bbb)
represents the number of digits inbbb
, e.glen(bbb)
is 3. (Same below)
aaa.bbb@cc
=aaabbb * base ^ (cc - len(bbb))
aaa
andbbb
are represented in native baseB
- This is consistent with the representation used by GNU GMP.
aaa.bbbEcc
=aaabbb * 10 ^ (cc - len(bbb))
E
could be lower case, baseB
must be 10aaa
andbbb
are all represented in decimal
0xaaa
or0xaaa
0xaaa.bbb
=0xaaabbb / 16 ^ len(bbb)
0xaaa.bbbPcc
=0xaaabbb / 16 ^ len(bbb) * 2 ^ cc
P
could be lower case, baseB
must be 2 (not 16!)aaa
andbbb
are represented in hexadecimal- This is consistent with the C++ hexadecimal literals.
aaa.bbbBcc
=aaabbb * 2 ^ (cc - len(bbb))
aaa.bbbOcc
=aaabbb * 8 ^ (cc - len(bbb))
aaa.bbbHcc
=aaabbb * 16 ^ (cc - len(bbb))
B
/O
/H
could be lower case, and baseB
must be consistent with the marker.aaa
andbbb
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.
§Examples
use dashu_base::Approximation::*;
let a = DBig::from_str_native("-1.23400e-3")?;
let b = DBig::from_str_native("-123.4@-05")?;
assert_eq!(a, b);
assert_eq!(a.precision(), 6);
assert_eq!(b.precision(), 4);
assert!(DBig::from_str_native("-0x1.234p-3").is_err());
assert!(DBig::from_str_native("-1.234H-3").is_err());
§Panics
Panics if the base B
is not between MIN_RADIX and MAX_RADIX inclusive.
source§impl<R: Round, const B: Word> FBig<R, B>
impl<R: Round, const B: Word> FBig<R, B>
sourcepub fn trunc(&self) -> Self
pub fn trunc(&self) -> Self
Get the integral part of the float
See FBig::round for how the output precision is determined.
§Examples
let a = DBig::from_str("1.234")?;
assert_eq!(a.trunc(), DBig::from_str("1")?);
// the actual precision of the integral part is 1 digit
assert_eq!(a.trunc().precision(), 1);
§Panics
Panics if the number is infinte
sourcepub fn split_at_point(self) -> (Self, Self)
pub fn split_at_point(self) -> (Self, Self)
Split the rational number into integral and fractional parts (split at the radix point)
It’s equivalent to (self.trunc(), self.fract())
§Examples
let a = DBig::from_str("1.234")?;
let (trunc, fract) = a.split_at_point();
assert_eq!(trunc, DBig::from_str("1.0")?);
assert_eq!(fract, DBig::from_str("0.234")?);
// the actual precision of the fractional part is 3 digits
assert_eq!(trunc.precision(), 1);
assert_eq!(fract.precision(), 3);
sourcepub fn fract(&self) -> Self
pub fn fract(&self) -> Self
Get the fractional part of the float
Note: this function will adjust the precision accordingly!
§Examples
let a = DBig::from_str("1.234")?;
assert_eq!(a.fract(), DBig::from_str("0.234")?);
// the actual precision of the fractional part is 3 digits
assert_eq!(a.fract().precision(), 3);
§Panics
Panics if the number is infinte
sourcepub fn ceil(&self) -> Self
pub fn ceil(&self) -> Self
Returns the smallest integer greater than or equal to self.
See FBig::round for how the output precision is determined.
§Examples
let a = DBig::from_str("1.234")?;
assert_eq!(a.ceil(), DBig::from_str("2")?);
// works for very large exponent
let b = DBig::from_str("1.234e10000")?;
assert_eq!(b.ceil(), b);
§Panics
Panics if the number is infinte
sourcepub fn floor(&self) -> Self
pub fn floor(&self) -> Self
Returns the largest integer less than or equal to self.
See FBig::round for how the output precision is determined.
§Examples
let a = DBig::from_str("1.234")?;
assert_eq!(a.floor(), DBig::from_str("1")?);
// works for very large exponent
let b = DBig::from_str("1.234e10000")?;
assert_eq!(b.floor(), b);
§Panics
Panics if the number is infinte
sourcepub fn round(&self) -> Self
pub fn round(&self) -> Self
Returns the integer nearest to self.
If there are two integers equally close, then the one farther from zero is chosen.
§Examples
let a = DBig::from_str("1.234")?;
assert_eq!(a.round(), DBig::from_str("1")?);
// works for very large exponent
let b = DBig::from_str("1.234e10000")?;
assert_eq!(b.round(), b);
§Precision
If self
is an integer, the result will have the same precision as self
.
If self
has fractional part, then the precision will be subtracted by the digits
in the fractional part. Examples:
1.00e100
(precision = 3) rounds to1.00e100
(precision = 3)1.234
(precision = 4) rounds to1.
(precision = 1)1.234e-10
(precision = 4) rounds to0.
(precision = 0, i.e arbitrary precision)
§Panics
Panics if the number is infinte
source§impl<R: Round, const B: Word> FBig<R, B>
impl<R: Round, const B: Word> FBig<R, B>
sourcepub const fn sign(&self) -> Sign
pub const fn sign(&self) -> Sign
Get the sign of the number. Zero value has a positive sign.
§Examples
assert_eq!(DBig::ZERO.sign(), Sign::Positive);
assert_eq!(DBig::from_str("-1.234")?.sign(), Sign::Negative);
sourcepub const fn signum(&self) -> Self
pub const fn signum(&self) -> Self
A number representing the sign of self
.
- FBig::ONE if the number is positive (including
inf
) - FBig::ZERO if the number is zero
- FBig::NEG_ONE if the number is negative (including
-inf
)
§Examples
assert_eq!(DBig::from_str("2.01")?.signum(), DBig::ONE);
assert_eq!(DBig::from_str("-1.234")?.signum(), DBig::NEG_ONE);
Trait Implementations§
source§impl<R: Round, const B: Word> AddAssign<&FBig<R, B>> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&FBig<R, B>> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &Self)
fn add_assign(&mut self, rhs: &Self)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&IBig> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&IBig> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &IBig)
fn add_assign(&mut self, rhs: &IBig)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&UBig> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&UBig> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &UBig)
fn add_assign(&mut self, rhs: &UBig)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&i128> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&i128> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &i128)
fn add_assign(&mut self, rhs: &i128)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&i16> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&i16> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &i16)
fn add_assign(&mut self, rhs: &i16)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&i32> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&i32> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &i32)
fn add_assign(&mut self, rhs: &i32)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&i64> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&i64> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &i64)
fn add_assign(&mut self, rhs: &i64)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&i8> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&i8> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &i8)
fn add_assign(&mut self, rhs: &i8)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&isize> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&isize> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &isize)
fn add_assign(&mut self, rhs: &isize)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&u128> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&u128> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &u128)
fn add_assign(&mut self, rhs: &u128)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&u16> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&u16> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &u16)
fn add_assign(&mut self, rhs: &u16)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&u32> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&u32> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &u32)
fn add_assign(&mut self, rhs: &u32)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&u64> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&u64> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &u64)
fn add_assign(&mut self, rhs: &u64)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&u8> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&u8> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &u8)
fn add_assign(&mut self, rhs: &u8)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<&usize> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<&usize> for FBig<R, B>
source§fn add_assign(&mut self, rhs: &usize)
fn add_assign(&mut self, rhs: &usize)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<IBig> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<IBig> for FBig<R, B>
source§fn add_assign(&mut self, rhs: IBig)
fn add_assign(&mut self, rhs: IBig)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<UBig> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<UBig> for FBig<R, B>
source§fn add_assign(&mut self, rhs: UBig)
fn add_assign(&mut self, rhs: UBig)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<i128> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<i128> for FBig<R, B>
source§fn add_assign(&mut self, rhs: i128)
fn add_assign(&mut self, rhs: i128)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<i16> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<i16> for FBig<R, B>
source§fn add_assign(&mut self, rhs: i16)
fn add_assign(&mut self, rhs: i16)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<i32> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<i32> for FBig<R, B>
source§fn add_assign(&mut self, rhs: i32)
fn add_assign(&mut self, rhs: i32)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<i64> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<i64> for FBig<R, B>
source§fn add_assign(&mut self, rhs: i64)
fn add_assign(&mut self, rhs: i64)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<i8> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<i8> for FBig<R, B>
source§fn add_assign(&mut self, rhs: i8)
fn add_assign(&mut self, rhs: i8)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<isize> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<isize> for FBig<R, B>
source§fn add_assign(&mut self, rhs: isize)
fn add_assign(&mut self, rhs: isize)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<u128> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<u128> for FBig<R, B>
source§fn add_assign(&mut self, rhs: u128)
fn add_assign(&mut self, rhs: u128)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<u16> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<u16> for FBig<R, B>
source§fn add_assign(&mut self, rhs: u16)
fn add_assign(&mut self, rhs: u16)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<u32> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<u32> for FBig<R, B>
source§fn add_assign(&mut self, rhs: u32)
fn add_assign(&mut self, rhs: u32)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<u64> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<u64> for FBig<R, B>
source§fn add_assign(&mut self, rhs: u64)
fn add_assign(&mut self, rhs: u64)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<u8> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<u8> for FBig<R, B>
source§fn add_assign(&mut self, rhs: u8)
fn add_assign(&mut self, rhs: u8)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign<usize> for FBig<R, B>
impl<R: Round, const B: Word> AddAssign<usize> for FBig<R, B>
source§fn add_assign(&mut self, rhs: usize)
fn add_assign(&mut self, rhs: usize)
+=
operation. Read moresource§impl<R: Round, const B: Word> AddAssign for FBig<R, B>
impl<R: Round, const B: Word> AddAssign for FBig<R, B>
source§fn add_assign(&mut self, rhs: Self)
fn add_assign(&mut self, rhs: Self)
+=
operation. Read moresource§impl<'de, R: Round, const B: Word> Deserialize<'de> for FBig<R, B>
impl<'de, R: Round, const B: Word> Deserialize<'de> for FBig<R, B>
source§fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
source§impl<R: Round, const B: Word> Distribution<FBig<R, B>> for Open01
impl<R: Round, const B: Word> Distribution<FBig<R, B>> for Open01
source§fn sample<RNG: Rng + ?Sized>(&self, rng: &mut RNG) -> FBig<R, B>
fn sample<RNG: Rng + ?Sized>(&self, rng: &mut RNG) -> FBig<R, B>
T
, using rng
as the source of randomness.source§fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
T
, using rng
as
the source of randomness. Read moresource§impl<R: Round, const B: Word> Distribution<FBig<R, B>> for OpenClosed01
impl<R: Round, const B: Word> Distribution<FBig<R, B>> for OpenClosed01
source§fn sample<RNG: Rng + ?Sized>(&self, rng: &mut RNG) -> FBig<R, B>
fn sample<RNG: Rng + ?Sized>(&self, rng: &mut RNG) -> FBig<R, B>
T
, using rng
as the source of randomness.source§fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
T
, using rng
as
the source of randomness. Read moresource§impl<R: Round, const B: Word> Distribution<FBig<R, B>> for Standard
impl<R: Round, const B: Word> Distribution<FBig<R, B>> for Standard
source§fn sample<RNG: Rng + ?Sized>(&self, rng: &mut RNG) -> FBig<R, B>
fn sample<RNG: Rng + ?Sized>(&self, rng: &mut RNG) -> FBig<R, B>
T
, using rng
as the source of randomness.source§fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
T
, using rng
as
the source of randomness. Read moresource§impl<R: Round, const B: Word> Distribution<FBig<R, B>> for Uniform01<B>
impl<R: Round, const B: Word> Distribution<FBig<R, B>> for Uniform01<B>
source§fn sample<RNG: Rng + ?Sized>(&self, rng: &mut RNG) -> FBig<R, B>
fn sample<RNG: Rng + ?Sized>(&self, rng: &mut RNG) -> FBig<R, B>
T
, using rng
as the source of randomness.source§fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
T
, using rng
as
the source of randomness. Read moresource§impl<R: Round, const B: Word> Distribution<FBig<R, B>> for UniformFBig<R, B>
impl<R: Round, const B: Word> Distribution<FBig<R, B>> for UniformFBig<R, B>
source§fn sample<RNG: Rng + ?Sized>(&self, rng: &mut RNG) -> FBig<R, B>
fn sample<RNG: Rng + ?Sized>(&self, rng: &mut RNG) -> FBig<R, B>
T
, using rng
as the source of randomness.source§fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
T
, using rng
as
the source of randomness. Read moresource§impl<R: Round, const B: Word> DivAssign<&FBig<R, B>> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&FBig<R, B>> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &Self)
fn div_assign(&mut self, rhs: &Self)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&IBig> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&IBig> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &IBig)
fn div_assign(&mut self, rhs: &IBig)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&UBig> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&UBig> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &UBig)
fn div_assign(&mut self, rhs: &UBig)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&i128> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&i128> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &i128)
fn div_assign(&mut self, rhs: &i128)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&i16> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&i16> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &i16)
fn div_assign(&mut self, rhs: &i16)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&i32> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&i32> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &i32)
fn div_assign(&mut self, rhs: &i32)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&i64> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&i64> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &i64)
fn div_assign(&mut self, rhs: &i64)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&i8> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&i8> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &i8)
fn div_assign(&mut self, rhs: &i8)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&isize> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&isize> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &isize)
fn div_assign(&mut self, rhs: &isize)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&u128> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&u128> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &u128)
fn div_assign(&mut self, rhs: &u128)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&u16> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&u16> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &u16)
fn div_assign(&mut self, rhs: &u16)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&u32> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&u32> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &u32)
fn div_assign(&mut self, rhs: &u32)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&u64> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&u64> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &u64)
fn div_assign(&mut self, rhs: &u64)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&u8> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&u8> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &u8)
fn div_assign(&mut self, rhs: &u8)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<&usize> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<&usize> for FBig<R, B>
source§fn div_assign(&mut self, rhs: &usize)
fn div_assign(&mut self, rhs: &usize)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<IBig> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<IBig> for FBig<R, B>
source§fn div_assign(&mut self, rhs: IBig)
fn div_assign(&mut self, rhs: IBig)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<UBig> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<UBig> for FBig<R, B>
source§fn div_assign(&mut self, rhs: UBig)
fn div_assign(&mut self, rhs: UBig)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<i128> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<i128> for FBig<R, B>
source§fn div_assign(&mut self, rhs: i128)
fn div_assign(&mut self, rhs: i128)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<i16> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<i16> for FBig<R, B>
source§fn div_assign(&mut self, rhs: i16)
fn div_assign(&mut self, rhs: i16)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<i32> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<i32> for FBig<R, B>
source§fn div_assign(&mut self, rhs: i32)
fn div_assign(&mut self, rhs: i32)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<i64> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<i64> for FBig<R, B>
source§fn div_assign(&mut self, rhs: i64)
fn div_assign(&mut self, rhs: i64)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<i8> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<i8> for FBig<R, B>
source§fn div_assign(&mut self, rhs: i8)
fn div_assign(&mut self, rhs: i8)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<isize> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<isize> for FBig<R, B>
source§fn div_assign(&mut self, rhs: isize)
fn div_assign(&mut self, rhs: isize)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<u128> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<u128> for FBig<R, B>
source§fn div_assign(&mut self, rhs: u128)
fn div_assign(&mut self, rhs: u128)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<u16> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<u16> for FBig<R, B>
source§fn div_assign(&mut self, rhs: u16)
fn div_assign(&mut self, rhs: u16)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<u32> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<u32> for FBig<R, B>
source§fn div_assign(&mut self, rhs: u32)
fn div_assign(&mut self, rhs: u32)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<u64> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<u64> for FBig<R, B>
source§fn div_assign(&mut self, rhs: u64)
fn div_assign(&mut self, rhs: u64)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<u8> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<u8> for FBig<R, B>
source§fn div_assign(&mut self, rhs: u8)
fn div_assign(&mut self, rhs: u8)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign<usize> for FBig<R, B>
impl<R: Round, const B: Word> DivAssign<usize> for FBig<R, B>
source§fn div_assign(&mut self, rhs: usize)
fn div_assign(&mut self, rhs: usize)
/=
operation. Read moresource§impl<R: Round, const B: Word> DivAssign for FBig<R, B>
impl<R: Round, const B: Word> DivAssign for FBig<R, B>
source§fn div_assign(&mut self, rhs: Self)
fn div_assign(&mut self, rhs: Self)
/=
operation. Read moresource§impl<R: Round, const B: Word> Euclid for FBig<R, B>
impl<R: Round, const B: Word> Euclid for FBig<R, B>
source§fn div_euclid(&self, v: &Self) -> Self
fn div_euclid(&self, v: &Self) -> Self
rem_euclid
. Read moresource§fn rem_euclid(&self, v: &Self) -> Self
fn rem_euclid(&self, v: &Self) -> Self
self (mod v)
. Read moresource§impl<R: Round, const B: Word> FromPrimitive for FBig<R, B>
impl<R: Round, const B: Word> FromPrimitive for FBig<R, B>
source§fn from_i8(n: i8) -> Option<Self>
fn from_i8(n: i8) -> Option<Self>
i8
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned.source§fn from_i16(n: i16) -> Option<Self>
fn from_i16(n: i16) -> Option<Self>
i16
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned.source§fn from_i32(n: i32) -> Option<Self>
fn from_i32(n: i32) -> Option<Self>
i32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned.source§fn from_i64(n: i64) -> Option<Self>
fn from_i64(n: i64) -> Option<Self>
i64
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned.source§fn from_i128(n: i128) -> Option<Self>
fn from_i128(n: i128) -> Option<Self>
i128
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read moresource§fn from_isize(n: isize) -> Option<Self>
fn from_isize(n: isize) -> Option<Self>
isize
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned.source§fn from_u8(n: u8) -> Option<Self>
fn from_u8(n: u8) -> Option<Self>
u8
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned.source§fn from_u16(n: u16) -> Option<Self>
fn from_u16(n: u16) -> Option<Self>
u16
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned.source§fn from_u32(n: u32) -> Option<Self>
fn from_u32(n: u32) -> Option<Self>
u32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned.source§fn from_u64(n: u64) -> Option<Self>
fn from_u64(n: u64) -> Option<Self>
u64
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned.source§fn from_u128(n: u128) -> Option<Self>
fn from_u128(n: u128) -> Option<Self>
u128
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read moresource§fn from_usize(n: usize) -> Option<Self>
fn from_usize(n: usize) -> Option<Self>
usize
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned.source§impl<'a, R: Round> FromSql<'a> for FBig<R, 10>
impl<'a, R: Round> FromSql<'a> for FBig<R, 10>
source§fn accepts(ty: &Type) -> bool
fn accepts(ty: &Type) -> bool
Type
.source§fn from_sql(
ty: &Type,
raw: &'a [u8]
) -> Result<Self, Box<dyn Error + Sync + Send>>
fn from_sql( ty: &Type, raw: &'a [u8] ) -> Result<Self, Box<dyn Error + Sync + Send>>
Type
in its binary format. Read moresource§impl<R: Round, const B: Word> FromStr for FBig<R, B>
impl<R: Round, const B: Word> FromStr for FBig<R, B>
§type Err = ParseError
type Err = ParseError
source§impl<R: Round, const B: Word> MulAssign<&FBig<R, B>> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&FBig<R, B>> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &Self)
fn mul_assign(&mut self, rhs: &Self)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&IBig> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&IBig> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &IBig)
fn mul_assign(&mut self, rhs: &IBig)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&UBig> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&UBig> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &UBig)
fn mul_assign(&mut self, rhs: &UBig)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&i128> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&i128> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &i128)
fn mul_assign(&mut self, rhs: &i128)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&i16> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&i16> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &i16)
fn mul_assign(&mut self, rhs: &i16)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&i32> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&i32> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &i32)
fn mul_assign(&mut self, rhs: &i32)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&i64> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&i64> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &i64)
fn mul_assign(&mut self, rhs: &i64)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&i8> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&i8> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &i8)
fn mul_assign(&mut self, rhs: &i8)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&isize> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&isize> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &isize)
fn mul_assign(&mut self, rhs: &isize)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&u128> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&u128> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &u128)
fn mul_assign(&mut self, rhs: &u128)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&u16> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&u16> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &u16)
fn mul_assign(&mut self, rhs: &u16)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&u32> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&u32> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &u32)
fn mul_assign(&mut self, rhs: &u32)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&u64> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&u64> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &u64)
fn mul_assign(&mut self, rhs: &u64)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&u8> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&u8> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &u8)
fn mul_assign(&mut self, rhs: &u8)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<&usize> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<&usize> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: &usize)
fn mul_assign(&mut self, rhs: &usize)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<IBig> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<IBig> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: IBig)
fn mul_assign(&mut self, rhs: IBig)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<Sign> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<Sign> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: Sign)
fn mul_assign(&mut self, rhs: Sign)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<UBig> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<UBig> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: UBig)
fn mul_assign(&mut self, rhs: UBig)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<i128> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<i128> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: i128)
fn mul_assign(&mut self, rhs: i128)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<i16> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<i16> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: i16)
fn mul_assign(&mut self, rhs: i16)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<i32> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<i32> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: i32)
fn mul_assign(&mut self, rhs: i32)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<i64> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<i64> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: i64)
fn mul_assign(&mut self, rhs: i64)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<i8> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<i8> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: i8)
fn mul_assign(&mut self, rhs: i8)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<isize> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<isize> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: isize)
fn mul_assign(&mut self, rhs: isize)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<u128> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<u128> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: u128)
fn mul_assign(&mut self, rhs: u128)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<u16> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<u16> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: u16)
fn mul_assign(&mut self, rhs: u16)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<u32> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<u32> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: u32)
fn mul_assign(&mut self, rhs: u32)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<u64> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<u64> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: u64)
fn mul_assign(&mut self, rhs: u64)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<u8> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<u8> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: u8)
fn mul_assign(&mut self, rhs: u8)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign<usize> for FBig<R, B>
impl<R: Round, const B: Word> MulAssign<usize> for FBig<R, B>
source§fn mul_assign(&mut self, rhs: usize)
fn mul_assign(&mut self, rhs: usize)
*=
operation. Read moresource§impl<R: Round, const B: Word> MulAssign for FBig<R, B>
impl<R: Round, const B: Word> MulAssign for FBig<R, B>
source§fn mul_assign(&mut self, rhs: Self)
fn mul_assign(&mut self, rhs: Self)
*=
operation. Read moresource§impl<R: Round, const B: Word> Num for FBig<R, B>
impl<R: Round, const B: Word> Num for FBig<R, B>
type FromStrRadixErr = ParseError
source§fn from_str_radix(s: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>
fn from_str_radix(s: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>
2..=36
). Read moresource§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for IBig
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for IBig
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for UBig
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for UBig
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for f32
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for f32
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for f64
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for f64
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for i128
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for i128
source§fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for i16
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for i16
source§fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for i32
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for i32
source§fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for i64
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for i64
source§fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for i8
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for i8
source§fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for isize
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for isize
source§fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for u128
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for u128
source§fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for u16
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for u16
source§fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for u32
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for u32
source§fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for u64
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for u64
source§fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for u8
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for u8
source§fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for usize
impl<R: Round, const B: Word> NumOrd<FBig<R, B>> for usize
source§fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>
source§impl<R1: Round, R2: Round, const B1: Word, const B2: Word> NumOrd<FBig<R2, B2>> for FBig<R1, B1>
impl<R1: Round, R2: Round, const B1: Word, const B2: Word> NumOrd<FBig<R2, B2>> for FBig<R1, B1>
source§impl<R: Round, const B: Word> NumOrd<IBig> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<IBig> for FBig<R, B>
source§impl<R: Round, const B: Word> NumOrd<UBig> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<UBig> for FBig<R, B>
source§impl<R: Round, const B: Word> NumOrd<f32> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<f32> for FBig<R, B>
source§impl<R: Round, const B: Word> NumOrd<f64> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<f64> for FBig<R, B>
source§impl<R: Round, const B: Word> NumOrd<i128> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<i128> for FBig<R, B>
source§fn num_partial_cmp(&self, other: &i128) -> Option<Ordering>
fn num_partial_cmp(&self, other: &i128) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<i16> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<i16> for FBig<R, B>
source§fn num_partial_cmp(&self, other: &i16) -> Option<Ordering>
fn num_partial_cmp(&self, other: &i16) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<i32> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<i32> for FBig<R, B>
source§fn num_partial_cmp(&self, other: &i32) -> Option<Ordering>
fn num_partial_cmp(&self, other: &i32) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<i64> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<i64> for FBig<R, B>
source§fn num_partial_cmp(&self, other: &i64) -> Option<Ordering>
fn num_partial_cmp(&self, other: &i64) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<i8> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<i8> for FBig<R, B>
source§fn num_partial_cmp(&self, other: &i8) -> Option<Ordering>
fn num_partial_cmp(&self, other: &i8) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<isize> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<isize> for FBig<R, B>
source§fn num_partial_cmp(&self, other: &isize) -> Option<Ordering>
fn num_partial_cmp(&self, other: &isize) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<u128> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<u128> for FBig<R, B>
source§fn num_partial_cmp(&self, other: &u128) -> Option<Ordering>
fn num_partial_cmp(&self, other: &u128) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<u16> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<u16> for FBig<R, B>
source§fn num_partial_cmp(&self, other: &u16) -> Option<Ordering>
fn num_partial_cmp(&self, other: &u16) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<u32> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<u32> for FBig<R, B>
source§fn num_partial_cmp(&self, other: &u32) -> Option<Ordering>
fn num_partial_cmp(&self, other: &u32) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<u64> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<u64> for FBig<R, B>
source§fn num_partial_cmp(&self, other: &u64) -> Option<Ordering>
fn num_partial_cmp(&self, other: &u64) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<u8> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<u8> for FBig<R, B>
source§fn num_partial_cmp(&self, other: &u8) -> Option<Ordering>
fn num_partial_cmp(&self, other: &u8) -> Option<Ordering>
source§impl<R: Round, const B: Word> NumOrd<usize> for FBig<R, B>
impl<R: Round, const B: Word> NumOrd<usize> for FBig<R, B>
source§fn num_partial_cmp(&self, other: &usize) -> Option<Ordering>
fn num_partial_cmp(&self, other: &usize) -> Option<Ordering>
source§impl<R: Round, const B: Word> Ord for FBig<R, B>
impl<R: Round, const B: Word> Ord for FBig<R, B>
source§impl<R1: Round, R2: Round, const B: Word> PartialEq<FBig<R2, B>> for FBig<R1, B>
impl<R1: Round, R2: Round, const B: Word> PartialEq<FBig<R2, B>> for FBig<R1, B>
source§impl<R1: Round, R2: Round, const B: Word> PartialOrd<FBig<R2, B>> for FBig<R1, B>
impl<R1: Round, R2: Round, const B: Word> PartialOrd<FBig<R2, B>> for FBig<R1, B>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<R: Round, const B: Word> RemAssign<&FBig<R, B>> for FBig<R, B>
impl<R: Round, const B: Word> RemAssign<&FBig<R, B>> for FBig<R, B>
source§fn rem_assign(&mut self, rhs: &Self)
fn rem_assign(&mut self, rhs: &Self)
%=
operation. Read moresource§impl<R: Round, const B: Word> RemAssign for FBig<R, B>
impl<R: Round, const B: Word> RemAssign for FBig<R, B>
source§fn rem_assign(&mut self, rhs: Self)
fn rem_assign(&mut self, rhs: Self)
%=
operation. Read moresource§impl<R: Round, const B: Word> SampleUniform for FBig<R, B>
impl<R: Round, const B: Word> SampleUniform for FBig<R, B>
§type Sampler = UniformFBig<R, B>
type Sampler = UniformFBig<R, B>
UniformSampler
implementation supporting type X
.source§impl<R: Round, const B: Word> ShlAssign<isize> for FBig<R, B>
impl<R: Round, const B: Word> ShlAssign<isize> for FBig<R, B>
source§fn shl_assign(&mut self, rhs: isize)
fn shl_assign(&mut self, rhs: isize)
<<=
operation. Read moresource§impl<R: Round, const B: Word> ShrAssign<isize> for FBig<R, B>
impl<R: Round, const B: Word> ShrAssign<isize> for FBig<R, B>
source§fn shr_assign(&mut self, rhs: isize)
fn shr_assign(&mut self, rhs: isize)
>>=
operation. Read moresource§impl<R: Round, const B: Word> Signed for FBig<R, B>
impl<R: Round, const B: Word> Signed for FBig<R, B>
source§fn is_positive(&self) -> bool
fn is_positive(&self) -> bool
source§fn is_negative(&self) -> bool
fn is_negative(&self) -> bool
source§impl<R: Round, const B: Word> SubAssign<&FBig<R, B>> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&FBig<R, B>> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &Self)
fn sub_assign(&mut self, rhs: &Self)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&IBig> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&IBig> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &IBig)
fn sub_assign(&mut self, rhs: &IBig)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&UBig> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&UBig> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &UBig)
fn sub_assign(&mut self, rhs: &UBig)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&i128> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&i128> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &i128)
fn sub_assign(&mut self, rhs: &i128)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&i16> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&i16> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &i16)
fn sub_assign(&mut self, rhs: &i16)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&i32> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&i32> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &i32)
fn sub_assign(&mut self, rhs: &i32)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&i64> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&i64> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &i64)
fn sub_assign(&mut self, rhs: &i64)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&i8> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&i8> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &i8)
fn sub_assign(&mut self, rhs: &i8)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&isize> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&isize> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &isize)
fn sub_assign(&mut self, rhs: &isize)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&u128> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&u128> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &u128)
fn sub_assign(&mut self, rhs: &u128)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&u16> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&u16> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &u16)
fn sub_assign(&mut self, rhs: &u16)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&u32> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&u32> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &u32)
fn sub_assign(&mut self, rhs: &u32)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&u64> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&u64> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &u64)
fn sub_assign(&mut self, rhs: &u64)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&u8> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&u8> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &u8)
fn sub_assign(&mut self, rhs: &u8)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<&usize> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<&usize> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: &usize)
fn sub_assign(&mut self, rhs: &usize)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<IBig> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<IBig> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: IBig)
fn sub_assign(&mut self, rhs: IBig)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<UBig> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<UBig> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: UBig)
fn sub_assign(&mut self, rhs: UBig)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<i128> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<i128> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: i128)
fn sub_assign(&mut self, rhs: i128)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<i16> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<i16> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: i16)
fn sub_assign(&mut self, rhs: i16)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<i32> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<i32> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: i32)
fn sub_assign(&mut self, rhs: i32)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<i64> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<i64> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: i64)
fn sub_assign(&mut self, rhs: i64)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<i8> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<i8> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: i8)
fn sub_assign(&mut self, rhs: i8)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<isize> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<isize> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: isize)
fn sub_assign(&mut self, rhs: isize)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<u128> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<u128> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: u128)
fn sub_assign(&mut self, rhs: u128)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<u16> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<u16> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: u16)
fn sub_assign(&mut self, rhs: u16)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<u32> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<u32> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: u32)
fn sub_assign(&mut self, rhs: u32)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<u64> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<u64> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: u64)
fn sub_assign(&mut self, rhs: u64)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<u8> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<u8> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: u8)
fn sub_assign(&mut self, rhs: u8)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign<usize> for FBig<R, B>
impl<R: Round, const B: Word> SubAssign<usize> for FBig<R, B>
source§fn sub_assign(&mut self, rhs: usize)
fn sub_assign(&mut self, rhs: usize)
-=
operation. Read moresource§impl<R: Round, const B: Word> SubAssign for FBig<R, B>
impl<R: Round, const B: Word> SubAssign for FBig<R, B>
source§fn sub_assign(&mut self, rhs: Self)
fn sub_assign(&mut self, rhs: Self)
-=
operation. Read moresource§impl<R: Round, const B: Word> ToPrimitive for FBig<R, B>
impl<R: Round, const B: Word> ToPrimitive for FBig<R, B>
source§fn to_i8(&self) -> Option<i8>
fn to_i8(&self) -> Option<i8>
self
to an i8
. If the value cannot be
represented by an i8
, then None
is returned.source§fn to_i16(&self) -> Option<i16>
fn to_i16(&self) -> Option<i16>
self
to an i16
. If the value cannot be
represented by an i16
, then None
is returned.source§fn to_i32(&self) -> Option<i32>
fn to_i32(&self) -> Option<i32>
self
to an i32
. If the value cannot be
represented by an i32
, then None
is returned.source§fn to_i64(&self) -> Option<i64>
fn to_i64(&self) -> Option<i64>
self
to an i64
. If the value cannot be
represented by an i64
, then None
is returned.source§fn to_i128(&self) -> Option<i128>
fn to_i128(&self) -> Option<i128>
self
to an i128
. If the value cannot be
represented by an i128
(i64
under the default implementation), then
None
is returned. Read moresource§fn to_isize(&self) -> Option<isize>
fn to_isize(&self) -> Option<isize>
self
to an isize
. If the value cannot be
represented by an isize
, then None
is returned.source§fn to_u8(&self) -> Option<u8>
fn to_u8(&self) -> Option<u8>
self
to a u8
. If the value cannot be
represented by a u8
, then None
is returned.source§fn to_u16(&self) -> Option<u16>
fn to_u16(&self) -> Option<u16>
self
to a u16
. If the value cannot be
represented by a u16
, then None
is returned.source§fn to_u32(&self) -> Option<u32>
fn to_u32(&self) -> Option<u32>
self
to a u32
. If the value cannot be
represented by a u32
, then None
is returned.source§fn to_u64(&self) -> Option<u64>
fn to_u64(&self) -> Option<u64>
self
to a u64
. If the value cannot be
represented by a u64
, then None
is returned.source§fn to_u128(&self) -> Option<u128>
fn to_u128(&self) -> Option<u128>
self
to a u128
. If the value cannot be
represented by a u128
(u64
under the default implementation), then
None
is returned. Read moresource§fn to_usize(&self) -> Option<usize>
fn to_usize(&self) -> Option<usize>
self
to a usize
. If the value cannot be
represented by a usize
, then None
is returned.source§impl<R: Round> ToSql for FBig<R, 10>
impl<R: Round> ToSql for FBig<R, 10>
source§fn accepts(ty: &Type) -> bool
fn accepts(ty: &Type) -> bool
Type
.source§fn to_sql(
&self,
ty: &Type,
out: &mut BytesMut
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
fn to_sql( &self, ty: &Type, out: &mut BytesMut ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
self
into the binary format of the specified
Postgres Type
, appending it to out
. Read moresource§fn to_sql_checked(
&self,
ty: &Type,
out: &mut BytesMut
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
fn to_sql_checked( &self, ty: &Type, out: &mut BytesMut ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
source§fn encode_format(&self, _ty: &Type) -> Format
fn encode_format(&self, _ty: &Type) -> Format
impl<R: Round, const B: Word> Eq for FBig<R, B>
Auto Trait Implementations§
impl<RoundingMode, const BASE: u64> RefUnwindSafe for FBig<RoundingMode, BASE>where
RoundingMode: RefUnwindSafe,
impl<RoundingMode, const BASE: u64> Send for FBig<RoundingMode, BASE>where
RoundingMode: Send,
impl<RoundingMode, const BASE: u64> Sync for FBig<RoundingMode, BASE>where
RoundingMode: Sync,
impl<RoundingMode, const BASE: u64> Unpin for FBig<RoundingMode, BASE>where
RoundingMode: Unpin,
impl<RoundingMode, const BASE: u64> UnwindSafe for FBig<RoundingMode, BASE>where
RoundingMode: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> BorrowToSql for Twhere
T: ToSql,
impl<T> BorrowToSql for Twhere
T: ToSql,
source§fn borrow_to_sql(&self) -> &dyn ToSql
fn borrow_to_sql(&self) -> &dyn ToSql
self
as a ToSql
trait object.source§impl<T, ST, DB> FromStaticSqlRow<ST, DB> for T
impl<T, ST, DB> FromStaticSqlRow<ST, DB> for T
source§impl<T> IntoSql for T
impl<T> IntoSql for T
source§fn into_sql<T>(self) -> Self::Expressionwhere
Self: AsExpression<T> + Sized,
fn into_sql<T>(self) -> Self::Expressionwhere
Self: AsExpression<T> + Sized,
self
to an expression for Diesel’s query builder. Read moresource§fn as_sql<'a, T>(&'a self) -> <&'a Self as AsExpression<T>>::Expressionwhere
&'a Self: AsExpression<T>,
fn as_sql<'a, T>(&'a self) -> <&'a Self as AsExpression<T>>::Expressionwhere
&'a Self: AsExpression<T>,
&self
to an expression for Diesel’s query builder. Read moresource§impl<T> IntoSql for T
impl<T> IntoSql for T
source§fn into_sql<T>(self) -> Self::Expression
fn into_sql<T>(self) -> Self::Expression
self
to an expression for Diesel’s query builder. Read moresource§fn as_sql<'a, T>(&'a self) -> <&'a Self as AsExpression<T>>::Expression
fn as_sql<'a, T>(&'a self) -> <&'a Self as AsExpression<T>>::Expression
&self
to an expression for Diesel’s query builder. Read moresource§impl<Borrowed> SampleBorrow<Borrowed> for Borrowedwhere
Borrowed: SampleUniform,
impl<Borrowed> SampleBorrow<Borrowed> for Borrowedwhere
Borrowed: SampleUniform,
source§fn borrow(&self) -> &Borrowed
fn borrow(&self) -> &Borrowed
Borrow::borrow