[−][src]Struct itchy::d128
A 128-bit decimal floating point type.
Methods
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 abs(self) -> d128
[src]
Returns the absolute value of self
.
pub fn mul_add<O>(self, a: O, b: O) -> d128 where
O: AsRef<d128>,
[src]
O: AsRef<d128>,
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>(self, other: O) -> d128 where
O: AsRef<d128>,
[src]
O: AsRef<d128>,
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>(self, other: O) -> d128 where
O: AsRef<d128>,
[src]
O: AsRef<d128>,
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>(self, exp: O) -> d128 where
O: AsRef<d128>,
[src]
O: AsRef<d128>,
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>(self, exp: O) -> d128 where
O: AsRef<d128>,
[src]
O: AsRef<d128>,
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>(self, other: O) -> d128 where
O: AsRef<d128>,
[src]
O: AsRef<d128>,
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>(self, other: O) -> d128 where
O: AsRef<d128>,
[src]
O: AsRef<d128>,
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>(self, amount: O) -> d128 where
O: AsRef<d128>,
[src]
O: AsRef<d128>,
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>(self, other: O) -> d128 where
O: AsRef<d128>,
[src]
O: AsRef<d128>,
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>(&self, other: O) -> d128 where
O: AsRef<d128>,
[src]
O: AsRef<d128>,
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>(&self, other: O) -> d128 where
O: AsRef<d128>,
[src]
O: AsRef<d128>,
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, '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]
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]
impl Add<d128> for d128
[src]
type Output = d128
The resulting type after applying the +
operator.
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.
fn add(self, other: d128) -> d128
[src]
impl AddAssign<d128> for d128
[src]
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.
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.
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.
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.
fn bitand(self, other: d128) -> d128
[src]
impl BitAndAssign<d128> for d128
[src]
fn bitand_assign(&mut self, other: d128)
[src]
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]
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]
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]
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]
impl BitOrAssign<d128> for d128
[src]
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.
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.
fn bitxor(self, other: &'a d128) -> d128
[src]
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]
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]
impl BitXorAssign<d128> for d128
[src]
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]
fn deserialize<D>(
deserializer: D
) -> Result<d128, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
[src]
deserializer: D
) -> Result<d128, <D as Deserializer<'de>>::Error> where
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, '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]
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]
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]
impl Div<d128> for d128
[src]
type Output = d128
The resulting type after applying the /
operator.
fn div(self, other: d128) -> d128
[src]
impl DivAssign<d128> for d128
[src]
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.
fn from_str(s: &str) -> Result<d128, ()>
[src]
impl Hash for d128
[src]
fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
H: Hasher,
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<d128> for Price4
[src]
impl Into<d128> for Price8
[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, '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]
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]
impl Mul<d128> for d128
[src]
type Output = d128
The resulting type after applying the *
operator.
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.
fn mul(self, other: d128) -> d128
[src]
impl MulAssign<d128> for d128
[src]
fn mul_assign(&mut self, other: d128)
[src]
impl Neg for d128
[src]
impl<'a> Neg for &'a d128
[src]
impl<'a> Not 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 OrdSubset for d128
[src]
fn is_outside_order(&self) -> bool
[src]
impl PartialEq<d128> for d128
[src]
impl PartialOrd<d128> for d128
[src]
fn partial_cmp(&self, other: &d128) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
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]
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]
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]
impl Rem<d128> for d128
[src]
type Output = d128
The resulting type after applying the %
operator.
fn rem(self, other: d128) -> d128
[src]
impl RemAssign<d128> for d128
[src]
fn rem_assign(&mut self, other: d128)
[src]
impl Serialize for d128
[src]
fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
S: Serializer,
[src]
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
S: Serializer,
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]
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]
impl ShlAssign<usize> for d128
[src]
fn shl_assign(&mut self, amount: usize)
[src]
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]
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]
impl ShrAssign<usize> for d128
[src]
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.
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.
fn sub(self, other: &'a d128) -> d128
[src]
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]
impl Sub<d128> for d128
[src]
type Output = d128
The resulting type after applying the -
operator.
fn sub(self, other: d128) -> d128
[src]
impl SubAssign<d128> for d128
[src]
fn sub_assign(&mut self, other: 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,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> DeserializeOwned for T where
T: Deserialize<'de>,
[src]
T: 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.
fn to_owned(&self) -> T
[src]
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.
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>,