Struct decimal::d128
[−]
[src]
#[repr(C)]pub struct d128 { /* fields omitted */ }
A 128-bit decimal floating point type.
Methods
impl d128
[src]
unsafe fn from_raw_bytes(bytes: [u8; 16]) -> d128
[src]
Creates a d128 from raw bytes. Endianess is host dependent.
fn to_raw_bytes(&self) -> [u8; 16]
[src]
Returns raw bytes for this d128. Endianess is host dependent.
fn get_status() -> Status
[src]
Returns the thread local status.
fn set_status(status: Status)
[src]
Sets the thread local status.
fn from_hex(s: &str) -> d128
[src]
Reads the hex binary representation from a string. This is the reverse of formatting with {:x}.
fn zero() -> d128
[src]
Returns the d128 representing +0.
fn abs(self) -> d128
[src]
Returns the absolute value of self
.
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.
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.
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.
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.
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).
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).
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.
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.
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.
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.
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.
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).
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.
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.
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.
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.
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.
fn canonical(self) -> d128
[src]
Returns self
ensuring that the encoding is canonical.
fn class(&self) -> Class
[src]
Returns the class of self
.
fn classify(&self) -> FpCategory
[src]
Same as class()
but returns std::num::FpCategory
.
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.
fn is_canonical(&self) -> bool
[src]
Returns true
if the encoding of self
is canonical, or false
otherwise.
fn is_finite(&self) -> bool
[src]
Returns true
if self
is neither infinite nor a NaN, or false
otherwise.
fn is_integer(&self) -> bool
[src]
Returns true
if self
is finite and its exponent is zero, or false
otherwise.
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.
fn is_infinite(&self) -> bool
[src]
Returns true
if the encoding of self
is an infinity, or false
otherwise.
fn is_nan(&self) -> bool
[src]
Returns true
if self
is a NaN (quiet or signaling), or false
otherwise.
fn is_negative(&self) -> bool
[src]
Returns true
if self
is less than zero and not a NaN, or false
otherwise.
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.
fn is_positive(&self) -> bool
[src]
Returns true
if self
is greater than zero and not a NaN, or false
otherwise.
fn is_signaling(&self) -> bool
[src]
Returns true
if self
is a signaling NaN, or false
otherwise.
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.
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.
fn is_zero(&self) -> bool
[src]
Returns true
if self
is zero, or false
otherwise.
Trait Implementations
impl Clone for d128
[src]
fn clone(&self) -> d128
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl Copy for d128
[src]
impl Default for d128
[src]
impl OrdSubset for d128
[src]
fn is_outside_order(&self) -> bool
[src]
impl Into<OrdVar<d128>> for d128
[src]
impl Decodable for d128
[src]
fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error>
[src]
Deserialize a value using a Decoder
.
impl Encodable for d128
[src]
fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error>
[src]
Serialize a value using an Encoder
.
impl Hash for d128
[src]
fn hash<H: Hasher>(&self, state: &mut H)
[src]
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl Serialize for d128
[src]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
Serialize this value into the given Serde serializer. Read more
impl<'de> Deserialize<'de> for d128
[src]
fn deserialize<D>(deserializer: D) -> Result<d128, D::Error> where
D: Deserializer<'de>,
[src]
D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
impl From<i32> for d128
[src]
Converts an i32 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 From<i64> for d128
[src]
Converts an i64 to d128. The result is exact and no error is possible.
impl AsRef<d128> for d128
[src]
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.
fn from_str(s: &str) -> Result<Self, ()>
[src]
Parses a string s
to return a value of this type. Read more
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 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.
fn fmt(&self, fmt: &mut Formatter) -> Result
[src]
Formats the value using the given formatter. Read more
impl Debug for d128
[src]
Same as fmt::Display
.
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 PartialEq<d128> for d128
[src]
fn eq(&self, other: &d128) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialOrd<d128> for d128
[src]
fn partial_cmp(&self, other: &d128) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl Add<d128> for d128
[src]
type Output = d128
The resulting type after applying the +
operator.
fn add(self, other: d128) -> d128
[src]
Performs the +
operation.
impl<'a> Add<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the +
operator.
fn add(self, other: d128) -> d128
[src]
Performs the +
operation.
impl<'a> Add<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the +
operator.
fn add(self, other: &'a d128) -> d128
[src]
Performs the +
operation.
impl<'a, 'b> Add<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the +
operator.
fn add(self, other: &'a d128) -> d128
[src]
Performs the +
operation.
impl Sub<d128> for d128
[src]
type Output = d128
The resulting type after applying the -
operator.
fn sub(self, other: d128) -> d128
[src]
Performs the -
operation.
impl<'a> Sub<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the -
operator.
fn sub(self, other: d128) -> d128
[src]
Performs the -
operation.
impl<'a> Sub<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the -
operator.
fn sub(self, other: &'a d128) -> d128
[src]
Performs the -
operation.
impl<'a, 'b> Sub<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the -
operator.
fn sub(self, other: &'a d128) -> d128
[src]
Performs the -
operation.
impl Mul<d128> for d128
[src]
type Output = d128
The resulting type after applying the *
operator.
fn mul(self, other: d128) -> d128
[src]
Performs the *
operation.
impl<'a> Mul<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the *
operator.
fn mul(self, other: d128) -> d128
[src]
Performs the *
operation.
impl<'a> Mul<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the *
operator.
fn mul(self, other: &'a d128) -> d128
[src]
Performs the *
operation.
impl<'a, 'b> Mul<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the *
operator.
fn mul(self, other: &'a d128) -> d128
[src]
Performs the *
operation.
impl Div<d128> for d128
[src]
type Output = d128
The resulting type after applying the /
operator.
fn div(self, other: d128) -> d128
[src]
Performs the /
operation.
impl<'a> Div<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the /
operator.
fn div(self, other: d128) -> d128
[src]
Performs the /
operation.
impl<'a> Div<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the /
operator.
fn div(self, other: &'a d128) -> d128
[src]
Performs the /
operation.
impl<'a, 'b> Div<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the /
operator.
fn div(self, other: &'a d128) -> d128
[src]
Performs the /
operation.
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.
fn bitand(self, other: d128) -> d128
[src]
Performs the &
operation.
impl<'a> BitAnd<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the &
operator.
fn bitand(self, other: d128) -> d128
[src]
Performs the &
operation.
impl<'a> BitAnd<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the &
operator.
fn bitand(self, other: &'a d128) -> d128
[src]
Performs the &
operation.
impl<'a, 'b> BitAnd<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the &
operator.
fn bitand(self, other: &'a d128) -> d128
[src]
Performs the &
operation.
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.
fn bitor(self, other: d128) -> d128
[src]
Performs the |
operation.
impl<'a> BitOr<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the |
operator.
fn bitor(self, other: d128) -> d128
[src]
Performs the |
operation.
impl<'a> BitOr<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the |
operator.
fn bitor(self, other: &'a d128) -> d128
[src]
Performs the |
operation.
impl<'a, 'b> BitOr<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the |
operator.
fn bitor(self, other: &'a d128) -> d128
[src]
Performs the |
operation.
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.
fn bitxor(self, other: d128) -> d128
[src]
Performs the ^
operation.
impl<'a> BitXor<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the ^
operator.
fn bitxor(self, other: d128) -> d128
[src]
Performs the ^
operation.
impl<'a> BitXor<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the ^
operator.
fn bitxor(self, other: &'a d128) -> d128
[src]
Performs the ^
operation.
impl<'a, 'b> BitXor<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the ^
operator.
fn bitxor(self, other: &'a d128) -> d128
[src]
Performs the ^
operation.
impl Rem<d128> for d128
[src]
type Output = d128
The resulting type after applying the %
operator.
fn rem(self, other: d128) -> d128
[src]
Performs the %
operation.
impl<'a> Rem<d128> for &'a d128
[src]
type Output = d128
The resulting type after applying the %
operator.
fn rem(self, other: d128) -> d128
[src]
Performs the %
operation.
impl<'a> Rem<&'a d128> for d128
[src]
type Output = d128
The resulting type after applying the %
operator.
fn rem(self, other: &'a d128) -> d128
[src]
Performs the %
operation.
impl<'a, 'b> Rem<&'a d128> for &'b d128
[src]
type Output = d128
The resulting type after applying the %
operator.
fn rem(self, other: &'a d128) -> d128
[src]
Performs the %
operation.
impl AddAssign<d128> for d128
[src]
fn add_assign(&mut self, other: d128)
[src]
Performs the +=
operation.
impl SubAssign<d128> for d128
[src]
fn sub_assign(&mut self, other: d128)
[src]
Performs the -=
operation.
impl MulAssign<d128> for d128
[src]
fn mul_assign(&mut self, other: d128)
[src]
Performs the *=
operation.
impl DivAssign<d128> for d128
[src]
fn div_assign(&mut self, other: d128)
[src]
Performs the /=
operation.
impl BitAndAssign<d128> for d128
[src]
fn bitand_assign(&mut self, other: d128)
[src]
Performs the &=
operation.
impl BitOrAssign<d128> for d128
[src]
fn bitor_assign(&mut self, other: d128)
[src]
Performs the |=
operation.
impl BitXorAssign<d128> for d128
[src]
fn bitxor_assign(&mut self, other: d128)
[src]
Performs the ^=
operation.
impl RemAssign<d128> for d128
[src]
fn rem_assign(&mut self, other: d128)
[src]
Performs the %=
operation.
impl Neg for d128
[src]
type Output = d128
The resulting type after applying the -
operator.
fn neg(self) -> d128
[src]
Performs the unary -
operation.
impl<'a> Neg for &'a d128
[src]
type Output = d128
The resulting type after applying the -
operator.
fn neg(self) -> d128
[src]
Performs the unary -
operation.
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.
type Output = d128
The resulting type after applying the !
operator.
fn not(self) -> d128
[src]
Performs the unary !
operation.
impl<'a> Not for &'a d128
[src]
type Output = d128
The resulting type after applying the !
operator.
fn not(self) -> d128
[src]
Performs the unary !
operation.
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.
fn shl(self, amount: usize) -> d128
[src]
Performs the <<
operation.
impl<'a> Shl<usize> for &'a d128
[src]
type Output = d128
The resulting type after applying the <<
operator.
fn shl(self, amount: usize) -> d128
[src]
Performs the <<
operation.
impl ShlAssign<usize> for d128
[src]
fn shl_assign(&mut self, amount: usize)
[src]
Performs the <<=
operation.
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.
fn shr(self, amount: usize) -> d128
[src]
Performs the >>
operation.
impl<'a> Shr<usize> for &'a d128
[src]
type Output = d128
The resulting type after applying the >>
operator.
fn shr(self, amount: usize) -> d128
[src]
Performs the >>
operation.
impl ShrAssign<usize> for d128
[src]
fn shr_assign(&mut self, amount: usize)
[src]
Performs the >>=
operation.