[−][src]Struct decimal_fixes_mirror::d128
A 128-bit decimal floating point type.
Implementations
impl d128
[src]
pub unsafe fn from_raw_bytes(bytes: [u8; 16]) -> d128
[src]
Creates a d128 from raw bytes. Endianess is host dependent.
pub fn to_raw_bytes(&self) -> [u8; 16]
[src]
Returns raw bytes for this d128. Endianess is host dependent.
pub fn get_status() -> Status
[src]
Returns the thread local status.
pub fn set_status(status: Status)
[src]
Sets the thread local status.
pub fn from_hex(s: &str) -> d128
[src]
Reads the hex binary representation from a string. This is the reverse of formatting with {:x}.
pub fn zero() -> d128
[src]
Returns the d128 representing +0.
pub fn infinity() -> d128
[src]
Returns the d128 representing +Infinity.
pub fn neg_infinity() -> d128
[src]
Returns the d128 representing -Infinity.
pub fn abs(self) -> d128
[src]
Returns the absolute value of self
.
pub fn mul_add<O: AsRef<d128>>(self, a: O, b: O) -> d128
[src]
Calculates the fused multiply-add self
× a
+ b
and returns the result. The multiply
is carried out first and is exact, so this operation has only the one, final, rounding.
pub fn logb(self) -> d128
[src]
Returns the adjusted exponent of self
, according to IEEE 754 rules. That is, the exponent
returned is calculated as if the decimal point followed the first significant digit (so,
for example, if self
were 123 then the result would be 2). If self
is infinite, the
result is +Infinity. If self
is a zero, the result is –Infinity, and the
DIVISION_BY_ZERO
flag is set. If self
is less than zero, the absolute value of self
is used. If self
is 1, the result is 0. NaNs are handled (propagated) as for arithmetic
operations.
pub fn max<O: AsRef<d128>>(self, other: O) -> d128
[src]
If both self
and other
are numeric (not NaNs) this returns the larger of the two
(compared using total ordering, to give a well-defined result). If either (but not both of)
is a quiet NaN then the other argument is the result; otherwise NaNs are handled as for
arithmetic operations.
pub fn min<O: AsRef<d128>>(self, other: O) -> d128
[src]
If both self
and other
are numeric (not NaNs) this returns the smaller of the two
(compared using total ordering, to give a well-defined result). If either (but not both of)
is a quiet NaN then the other argument is the result; otherwise NaNs are handled as for
arithmetic operations.
pub fn next(self) -> d128
[src]
Returns the ‘next’ d128 to self
in the direction of +Infinity according to IEEE 754 rules
for nextUp. The only status possible is INVALID_OPERATION
(from an sNaN).
pub fn previous(self) -> d128
[src]
Returns the ‘next’ d128 to self
in the direction of –Infinity according to IEEE 754 rules
for nextDown. The only status possible is INVALID_OPERATION
(from an sNaN).
pub fn pow<O: AsRef<d128>>(self, exp: O) -> d128
[src]
The number is set to the result of raising self
to the power of exp
. Results will be
exact when exp
has an integral value and the result does not need to be rounded, and also
will be exact in certain special cases, such as when self
is a zero (see the arithmetic
specification for details). Inexact results will always be full precision, and will almost
always be correctly rounded, but may be up to 1 ulp (unit in last place) in error in rare
cases. This is a mathematical function; the 106 restrictions on precision and
range apply as described above, except that the normal range of values is allowed if exp
has an integral value in the range –1999999997 through +999999999.
pub fn exp<O: AsRef<d128>>(self, exp: O) -> d128
[src]
The number is set to e raised to the power of exp
. Finite results will always be full
precision and inexact, except when exp
is a zero or –Infinity (giving 1 or 0
respectively). Inexact results will almost always be correctly rounded, but may be up to 1
ulp (unit in last place) in error in rare cases. This is a mathematical function; the
106 restrictions on precision and range apply as described above.
pub fn ln(self) -> d128
[src]
The number is set to the natural logarithm (logarithm in base e) of self
. self
must be
positive or a zero. Finite results will always be full precision and inexact, except when
self
is equal to 1, which gives an exact result of 0. Inexact results will almost always
be correctly rounded, but may be up to 1 ulp (unit in last place) in error in rare cases.
This is a mathematical function; the 106 restrictions on precision and range
apply as described above.
pub fn log10(self) -> d128
[src]
The number is set to the logarithm in base ten of self
. self
must be positive or a
zero. Finite results will always be full precision and inexact, except when self
is equal
to an integral power of ten, in which case the result is the exact integer. Inexact results
will almost always be correctly rounded, but may be up to 1 ulp (unit in last place) in
error in rare cases. This is a mathematical function; the 106 restrictions on
precision and range apply as described above.
pub fn towards<O: AsRef<d128>>(self, other: O) -> d128
[src]
Returns the ‘next’ d128 to self
in the direction of other
according to proposed IEEE
754 rules for nextAfter. If self
== other
the result is self
. If either operand is
a NaN the result is as for arithmetic operations. Otherwise (the operands are numeric and
different) the result of adding (or subtracting) an infinitesimal positive amount to self
and rounding towards +Infinity (or –Infinity) is returned, depending on whether other
is
larger (or smaller) than self
. The addition will set flags, except that if the result is
normal (finite, non-zero, and not subnormal) no flags are set.
pub fn quantize<O: AsRef<d128>>(self, other: O) -> d128
[src]
Returns self
set to have the same quantum as other
, if possible (that is, numerically
the same value but rounded or padded if necessary to have the same exponent as other
, for
example to round a monetary quantity to cents).
pub fn reduce(self) -> d128
[src]
Returns a copy of self
with its coefficient reduced to its shortest possible form without
changing the value of the result. This removes all possible trailing zeros from the
coefficient (some may remain when the number is very close to the most positive or most
negative number). Infinities and NaNs are unchanged and no status is set unless self
is
an sNaN. If self
is a zero the result exponent is 0.
pub fn rotate<O: AsRef<d128>>(self, amount: O) -> d128
[src]
The result is a copy of self
with the digits of the coefficient rotated to the left (if
amount
is positive) or to the right (if amount
is negative) without adjusting the
exponent or the sign of self
. amount
is the count of positions to rotate and must be a
finite integer (with exponent=0) in the range -34 through +34. NaNs are propagated as
usual. If self
is infinite the result is Infinity of the same sign. No status is set
unless amount
is invalid or an operand is an sNaN.
pub fn scaleb<O: AsRef<d128>>(self, other: O) -> d128
[src]
This calculates self
× 10other
and returns the result. other
must be an
integer (finite with exponent=0) in the range ±2 × (34 + 6144), typically resulting from
logb
. Underflow and overflow might occur. NaNs propagate as usual.
pub fn compare<O: AsRef<d128>>(&self, other: O) -> d128
[src]
Compares self
and other
numerically and returns the result. The result may be –1, 0, 1,
or NaN (unordered); –1 indicates that self
is less than other
, 0 indicates that they
are numerically equal, and 1 indicates that self
is greater than other
. NaN is returned
only if self
or other
is a NaN.
pub fn compare_total<O: AsRef<d128>>(&self, other: O) -> d128
[src]
Compares self
and other
using the IEEE 754 total ordering (which takes into account the
exponent) and returns the result. No status is set (a signaling NaN is ordered between
Infinity and NaN). The result will be –1, 0, or 1.
pub fn canonical(self) -> d128
[src]
Returns self
ensuring that the encoding is canonical.
pub fn class(&self) -> Class
[src]
Returns the class of self
.
pub fn classify(&self) -> FpCategory
[src]
Same as class()
but returns std::num::FpCategory
.
pub fn digits(&self) -> u32
[src]
Returns the number of significant digits in self
. If self
is a zero or is infinite, 1
is returned. If self
is a NaN then the number of digits in the payload is returned.
pub fn is_canonical(&self) -> bool
[src]
Returns true
if the encoding of self
is canonical, or false
otherwise.
pub fn is_finite(&self) -> bool
[src]
Returns true
if self
is neither infinite nor a NaN, or false
otherwise.
pub fn is_integer(&self) -> bool
[src]
Returns true
if self
is finite and its exponent is zero, or false
otherwise.
pub fn is_logical(&self) -> bool
[src]
Returns true
if self
is a valid argument for logical operations (that is, self
is
zero or positive, an integer (finite with a zero exponent) and comprises only zeros and/or
ones), or false
otherwise.
pub fn is_infinite(&self) -> bool
[src]
Returns true
if the encoding of self
is an infinity, or false
otherwise.
pub fn is_nan(&self) -> bool
[src]
Returns true
if self
is a NaN (quiet or signaling), or false
otherwise.
pub fn is_negative(&self) -> bool
[src]
Returns true
if self
is less than zero and not a NaN, or false
otherwise.
pub fn is_normal(&self) -> bool
[src]
Returns true
if self
is a normal number (that is, is finite, non-zero, and not
subnormal), or false
otherwise.
pub fn is_positive(&self) -> bool
[src]
Returns true
if self
is greater than zero and not a NaN, or false
otherwise.
pub fn is_signaling(&self) -> bool
[src]
Returns true
if self
is a signaling NaN, or false
otherwise.
pub fn is_signed(&self) -> bool
[src]
Returns true
if self
has a minus sign, or false
otherwise. Note that zeros and NaNs
may have a minus sign.
pub fn is_subnormal(&self) -> bool
[src]
Returns true
if self
is subnormal (that is, finite, non-zero, and with magnitude less
than 10-6143), or false
otherwise.
pub fn is_zero(&self) -> bool
[src]
Returns true
if self
is zero, or false
otherwise.
Trait Implementations
impl<'a> Add<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the +
operator.
pub fn add(self, other: &'a d128) -> d128
[src]
impl<'a, 'b> Add<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the +
operator.
pub fn add(self, other: &'a d128) -> d128
[src]
impl Add<d128> for d128
[src]
type Output = d128
The resulting type after applying the +
operator.
pub fn add(self, other: d128) -> d128
[src]
impl<'a> Add<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the +
operator.
pub fn add(self, other: d128) -> d128
[src]
impl AddAssign<d128> for d128
[src]
pub fn add_assign(&mut self, other: d128)
[src]
impl AsRef<d128> for d128
[src]
impl<'a> BitAnd<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the &
operator.
pub fn bitand(self, other: &'a d128) -> d128
[src]
impl<'a, 'b> BitAnd<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the &
operator.
pub fn bitand(self, other: &'a d128) -> d128
[src]
impl BitAnd<d128> for d128
[src]
The operands must be zero or positive, an integer (finite with zero exponent) and comprise only zeros and/or ones; if not, INVALID_OPERATION is set.
type Output = d128
The resulting type after applying the &
operator.
pub fn bitand(self, other: d128) -> d128
[src]
impl<'a> BitAnd<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the &
operator.
pub fn bitand(self, other: d128) -> d128
[src]
impl BitAndAssign<d128> for d128
[src]
pub fn bitand_assign(&mut self, other: d128)
[src]
impl<'a> BitOr<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the |
operator.
pub fn bitor(self, other: &'a d128) -> d128
[src]
impl<'a, 'b> BitOr<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the |
operator.
pub fn bitor(self, other: &'a d128) -> d128
[src]
impl BitOr<d128> for d128
[src]
The operands must be zero or positive, an integer (finite with zero exponent) and comprise only zeros and/or ones; if not, INVALID_OPERATION is set.
type Output = d128
The resulting type after applying the |
operator.
pub fn bitor(self, other: d128) -> d128
[src]
impl<'a> BitOr<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the |
operator.
pub fn bitor(self, other: d128) -> d128
[src]
impl BitOrAssign<d128> for d128
[src]
pub fn bitor_assign(&mut self, other: d128)
[src]
impl<'a> BitXor<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the ^
operator.
pub fn bitxor(self, other: &'a d128) -> d128
[src]
impl<'a, 'b> BitXor<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the ^
operator.
pub fn bitxor(self, other: &'a d128) -> d128
[src]
impl BitXor<d128> for d128
[src]
The operands must be zero or positive, an integer (finite with zero exponent) and comprise only zeros and/or ones; if not, INVALID_OPERATION is set.
type Output = d128
The resulting type after applying the ^
operator.
pub fn bitxor(self, other: d128) -> d128
[src]
impl<'a> BitXor<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the ^
operator.
pub fn bitxor(self, other: d128) -> d128
[src]
impl BitXorAssign<d128> for d128
[src]
pub fn bitxor_assign(&mut self, other: d128)
[src]
impl Clone for d128
[src]
impl Copy for d128
[src]
impl Debug for d128
[src]
Same as fmt::Display
.
impl Decodable for d128
[src]
impl Default for d128
[src]
impl<'de> Deserialize<'de> for d128
[src]
pub fn deserialize<D>(deserializer: D) -> Result<d128, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
impl Display for d128
[src]
Formats a d128. Finite numbers will be converted to a string with exponential notation if the exponent is positive or if the magnitude of x is less than 1 and would require more than five zeros between the decimal point and the first significant digit. Note that strings which are not simply numbers (one of Infinity, –Infinity, NaN, or sNaN) are possible. A NaN string may have a leading – sign and/or following payload digits. No digits follow the NaN string if the payload is 0.
impl<'a> Div<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the /
operator.
pub fn div(self, other: &'a d128) -> d128
[src]
impl<'a, 'b> Div<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the /
operator.
pub fn div(self, other: &'a d128) -> d128
[src]
impl Div<d128> for d128
[src]
type Output = d128
The resulting type after applying the /
operator.
pub fn div(self, other: d128) -> d128
[src]
impl<'a> Div<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the /
operator.
pub fn div(self, other: d128) -> d128
[src]
impl DivAssign<d128> for d128
[src]
pub fn div_assign(&mut self, other: d128)
[src]
impl Encodable for d128
[src]
impl From<i32> for d128
[src]
Converts an i32 to d128. The result is exact and no error is possible.
impl From<i64> for d128
[src]
Converts an i64 to d128. The result is exact and no error is possible.
impl From<u32> for d128
[src]
Converts an u32 to d128. The result is exact and no error is possible.
impl From<u64> for d128
[src]
Converts an u64 to d128. The result is exact and no error is possible.
impl FromStr for d128
[src]
Converts a string to d128. The length of the coefficient and the size of the exponent are
checked by this routine, so rounding will be applied if necessary, and this may set status
flags (UNDERFLOW
, OVERFLOW
) will be reported, or rounding applied, as necessary. There is
no limit to the coefficient length for finite inputs; NaN payloads must be integers with no
more than 33 digits. Exponents may have up to nine significant digits. The syntax of the string
is fully checked; if it is not valid, the result will be a quiet NaN and an error flag will be
set.
type Err = ()
The associated error which can be returned from parsing.
pub fn from_str(s: &str) -> Result<Self, ()>
[src]
impl Hash for d128
[src]
pub fn hash<H: Hasher>(&self, state: &mut H)
[src]
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl Into<OrdVar<d128>> for d128
[src]
impl Into<i32> for d128
[src]
Converts this d128 to an i32. It uses Rounding::HalfEven.
impl Into<u32> for d128
[src]
Converts this d128 to an u32. It uses Rounding::HalfEven.
impl LowerExp for d128
[src]
Formats a d128 with engineering notation. This is the same as fmt::Display except that if exponential notation is used the exponent will be a multiple of 3.
impl LowerHex for d128
[src]
Formats a d128 to hexadecimal binary representation.
impl<'a> Mul<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the *
operator.
pub fn mul(self, other: &'a d128) -> d128
[src]
impl<'a, 'b> Mul<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the *
operator.
pub fn mul(self, other: &'a d128) -> d128
[src]
impl Mul<d128> for d128
[src]
type Output = d128
The resulting type after applying the *
operator.
pub fn mul(self, other: d128) -> d128
[src]
impl<'a> Mul<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the *
operator.
pub fn mul(self, other: d128) -> d128
[src]
impl MulAssign<d128> for d128
[src]
pub fn mul_assign(&mut self, other: d128)
[src]
impl Neg for d128
[src]
impl<'a> Neg for &'a d128
[src]
impl Not for d128
[src]
The operand must be zero or positive, an integer (finite with zero exponent) and comprise only zeros and/or ones; if not, INVALID_OPERATION is set.
impl<'a> Not for &'a d128
[src]
impl OrdSubset for d128
[src]
pub fn is_outside_order(&self) -> bool
[src]
impl PartialEq<d128> for d128
[src]
pub fn eq(&self, other: &d128) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl PartialOrd<d128> for d128
[src]
pub fn partial_cmp(&self, other: &d128) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a> Rem<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the %
operator.
pub fn rem(self, other: &'a d128) -> d128
[src]
impl<'a, 'b> Rem<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the %
operator.
pub fn rem(self, other: &'a d128) -> d128
[src]
impl Rem<d128> for d128
[src]
type Output = d128
The resulting type after applying the %
operator.
pub fn rem(self, other: d128) -> d128
[src]
impl<'a> Rem<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the %
operator.
pub fn rem(self, other: d128) -> d128
[src]
impl RemAssign<d128> for d128
[src]
pub fn rem_assign(&mut self, other: d128)
[src]
impl Serialize for d128
[src]
impl Shl<usize> for d128
[src]
The result is self
with the digits of the coefficient shifted to the left without adjusting
the exponent or the sign of self
. Any digits ‘shifted in’ from the right will be 0. amount
is the count of positions to shift and must be a in the range –34 through +34. NaNs are
propagated as usual. If self
is infinite the result is Infinity of the same sign. No status
is set unless amount
is invalid or self
is an sNaN.
type Output = d128
The resulting type after applying the <<
operator.
pub fn shl(self, amount: usize) -> d128
[src]
impl<'a> Shl<usize> for &'a d128
[src]
type Output = d128
The resulting type after applying the <<
operator.
pub fn shl(self, amount: usize) -> d128
[src]
impl ShlAssign<usize> for d128
[src]
pub fn shl_assign(&mut self, amount: usize)
[src]
impl Shr<usize> for d128
[src]
The result is self
with the digits of the coefficient shifted to the right without adjusting
the exponent or the sign of self
. Any digits ‘shifted in’ from the left will be 0. amount
is the count of positions to shift and must be a in the range –34 through +34. NaNs are
propagated as usual. If self
is infinite the result is Infinity of the same sign. No status
is set unless amount
is invalid or self
is an sNaN.
type Output = d128
The resulting type after applying the >>
operator.
pub fn shr(self, amount: usize) -> d128
[src]
impl<'a> Shr<usize> for &'a d128
[src]
type Output = d128
The resulting type after applying the >>
operator.
pub fn shr(self, amount: usize) -> d128
[src]
impl ShrAssign<usize> for d128
[src]
pub fn shr_assign(&mut self, amount: usize)
[src]
impl<'a> Sub<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the -
operator.
pub fn sub(self, other: &'a d128) -> d128
[src]
impl<'a, 'b> Sub<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the -
operator.
pub fn sub(self, other: &'a d128) -> d128
[src]
impl Sub<d128> for d128
[src]
type Output = d128
The resulting type after applying the -
operator.
pub fn sub(self, other: d128) -> d128
[src]
impl<'a> Sub<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the -
operator.
pub fn sub(self, other: d128) -> d128
[src]
impl SubAssign<d128> for d128
[src]
pub fn sub_assign(&mut self, other: d128)
[src]
impl<T> Sum<T> for d128 where
T: Borrow<d128>,
[src]
T: Borrow<d128>,
pub fn sum<I: IntoIterator<Item = T>>(iter: I) -> d128
[src]
Auto Trait Implementations
impl RefUnwindSafe for d128
impl Send for d128
impl Sync for d128
impl Unpin for d128
impl UnwindSafe for d128
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> DeserializeOwned for T where
T: for<'de> Deserialize<'de>,
[src]
T: for<'de> Deserialize<'de>,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,