Struct dec::Decimal128

pub struct Decimal128 { /* private fields */ }

A 128-bit decimal floating-point number.

Additional operations are defined as methods on the Context type.

For convenience, Decimal128 overloads many of the standard Rust operators. For example, you can use the standard + operator to add two values together:

use dec::Decimal128;
let a = Decimal128::from(1);
let b = Decimal128::from(2);
assert_eq!(a + b, Decimal128::from(3));

These overloaded operators implicitly construct a single-use default context, which has some performance overhead. For maximum performance when performing operations in bulk, use a long-lived context that you construct yourself.

Implementations

impl Decimal128

pub const NAN: Decimal128 = _

The value that represents Not-a-Number (NaN).

pub const ZERO: Decimal128 = _

The value that represents zero.

pub const ONE: Decimal128 = _

The value that represents one.

pub fn from_le_bytes(bytes: [u8; 16]) -> Decimal128

Creates a number from its representation as a little-endian byte array.

pub fn from_be_bytes(bytes: [u8; 16]) -> Decimal128

Creates a number from its representation as a big-endian byte array.

pub const fn from_ne_bytes(bytes: [u8; 16]) -> Decimal128

Creates a number from its representation as a byte array in the native endianness of the target platform.

pub fn to_le_bytes(&self) -> [u8; 16]

Returns the memory representation of the number as a byte array in little-endian order.

pub fn to_be_bytes(&self) -> [u8; 16]

Returns the memory representation of the number as a byte array in big-endian order.

pub fn to_ne_bytes(&self) -> [u8; 16]

Returns the memory representation of the number as a byte array in the native endianness of the target platform.

pub fn class(&self) -> Class

Classifies the number.

pub fn digits(&self) -> u32

Computes the number of significant digits in the number.

If the number is zero or infinite, returns 1. If the number is a NaN, returns the number of digits in the payload.

pub fn coefficient(&self) -> i128

Computes the coefficient of the number.

If the number is a special value (i.e., NaN or infinity), returns zero.

pub fn coefficient_digits(&self) -> [u8; 34]

Returns the individual digits of the coefficient in 8-bit, unpacked binary-coded decimal format.

pub fn exponent(&self) -> i32

Computes the exponent of the number.

pub fn canonical(self) -> Decimal128

Returns an equivalent number whose encoding is guaranteed to be canonical.

pub fn is_canonical(&self) -> bool

Reports whether the encoding of the number is canonical.

pub fn is_finite(&self) -> bool

Reports whether the number is finite.

A finite number is one that is neither infinite nor a NaN.

pub fn is_infinite(&self) -> bool

Reports whether the number is positive or negative infinity.

pub fn is_integer(&self) -> bool

Reports whether the number is an integer.

An integer is a decimal number that is finite and has an exponent of zero.

pub fn is_logical(&self) -> bool

Reports whether the number is a valid argument for logical operations.

A number is a valid argument for logical operations if it is a nonnegative integer where each digit is either zero or one.

pub fn is_nan(&self) -> bool

Reports whether the number is a NaN.

pub fn is_negative(&self) -> bool

Reports whether the number is less than zero and not a NaN.

pub fn is_normal(&self) -> bool

Reports whether the number is normal.

A normal number is finite, non-zero, and not subnormal.

pub fn is_positive(&self) -> bool

Reports whether the number is greater than zero and not a NaN.

pub fn is_signaling_nan(&self) -> bool

Reports whether the number is a signaling NaN.

pub fn is_signed(&self) -> bool

Reports whether the number has a sign of 1.

Note that zeros and NaNs may have a sign of 1.

pub fn is_subnormal(&self) -> bool

Reports whether the number is subnormal.

A subnormal number is finite, non-zero, and has magnitude less than 10^emin.

pub fn is_zero(&self) -> bool

Reports whether the number is positive or negative zero.

pub fn quantum_matches(&self, rhs: &Decimal128) -> bool

Reports whether the quantum of the number matches the quantum of rhs.

Quantums are considered to match if the numbers have the same exponent, are both NaNs, or both infinite.

pub fn total_cmp(&self, rhs: &Decimal128) -> Ordering

Determines the ordering of this number relative to rhs, using the total order predicate defined in IEEE 754-2008.

For a brief description of the ordering, consult f32::total_cmp.

pub fn to_standard_notation_string(&self) -> String

Returns a string of the number in standard notation, i.e. guaranteed to not be scientific notation.

Trait Implementations

impl Add<OrderedDecimal<Decimal128>> for Decimal128

type Output = Decimal128

The resulting type after applying the + operator.

fn add(self, other: OrderedDecimal<Decimal128>) -> Self

Performs the + operation.

impl Add for Decimal128

type Output = Decimal128

The resulting type after applying the + operator.

fn add(self, rhs: Decimal128) -> Decimal128

Performs the + operation.

impl AddAssign for Decimal128

fn add_assign(&mut self, rhs: Decimal128)

Performs the += operation.

impl Clone for Decimal128

fn clone(&self) -> Decimal128

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Decimal128

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

Formats the value using the given formatter.

impl Default for Decimal128

fn default() -> Decimal128

Returns the “default value” for a type.

impl Display for Decimal128

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

Formats the value using the given formatter.

impl Div<OrderedDecimal<Decimal128>> for Decimal128

type Output = Decimal128

The resulting type after applying the / operator.

fn div(self, other: OrderedDecimal<Decimal128>) -> Self

Performs the / operation.

impl Div for Decimal128

type Output = Decimal128

The resulting type after applying the / operator.

fn div(self, rhs: Decimal128) -> Decimal128

Performs the / operation.

impl DivAssign for Decimal128

fn div_assign(&mut self, rhs: Decimal128)

Performs the /= operation.

impl<const N: usize> From<Decimal128> for Decimal<N>

fn from(n: Decimal128) -> Decimal<N>

Converts to this type from the input type.

impl<D> From<Decimal128> for OrderedDecimal<D>

where D: From<Decimal128>,

fn from(n: Decimal128) -> OrderedDecimal<D>

Converts to this type from the input type.

impl From<Decimal32> for Decimal128

fn from(d32: Decimal32) -> Decimal128

Converts to this type from the input type.

impl From<Decimal64> for Decimal128

fn from(d64: Decimal64) -> Decimal128

Converts to this type from the input type.

impl From<i32> for Decimal128

fn from(n: i32) -> Decimal128

Converts to this type from the input type.

impl From<i64> for Decimal128

fn from(n: i64) -> Decimal128

Converts to this type from the input type.

impl From<u32> for Decimal128

fn from(n: u32) -> Decimal128

Converts to this type from the input type.

impl From<u64> for Decimal128

fn from(n: u64) -> Decimal128

Converts to this type from the input type.

impl FromStr for Decimal128

type Err = ParseDecimalError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Decimal128, ParseDecimalError>

Parses a string s to return a value of this type.

impl Mul<OrderedDecimal<Decimal128>> for Decimal128

type Output = Decimal128

The resulting type after applying the * operator.

fn mul(self, other: OrderedDecimal<Decimal128>) -> Self

Performs the * operation.

impl Mul for Decimal128

type Output = Decimal128

The resulting type after applying the * operator.

fn mul(self, rhs: Decimal128) -> Decimal128

Performs the * operation.

impl MulAssign for Decimal128

fn mul_assign(&mut self, rhs: Decimal128)

Performs the *= operation.

impl Neg for Decimal128

type Output = Decimal128

The resulting type after applying the - operator.

fn neg(self) -> Decimal128

Performs the unary - operation.

impl PartialEq for Decimal128

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Decimal128

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Product<&'a Decimal128> for Decimal128

fn product<I>(iter: I) -> Self

where I: Iterator<Item = &'a Decimal128>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl Product for Decimal128

fn product<I>(iter: I) -> Self

where I: Iterator<Item = Decimal128>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl Rem<OrderedDecimal<Decimal128>> for Decimal128

type Output = Decimal128

The resulting type after applying the % operator.

fn rem(self, other: OrderedDecimal<Decimal128>) -> Self

Performs the % operation.

impl Rem for Decimal128

type Output = Decimal128

The resulting type after applying the % operator.

fn rem(self, rhs: Decimal128) -> Decimal128

Performs the % operation.

impl RemAssign for Decimal128

fn rem_assign(&mut self, rhs: Decimal128)

Performs the %= operation.

impl Sub<OrderedDecimal<Decimal128>> for Decimal128

type Output = Decimal128

The resulting type after applying the - operator.

fn sub(self, other: OrderedDecimal<Decimal128>) -> Self

Performs the - operation.

impl Sub for Decimal128

type Output = Decimal128

The resulting type after applying the - operator.

fn sub(self, rhs: Decimal128) -> Decimal128

Performs the - operation.

impl SubAssign for Decimal128

fn sub_assign(&mut self, rhs: Decimal128)

Performs the -= operation.

impl<'a> Sum<&'a Decimal128> for Decimal128

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = &'a Decimal128>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Sum for Decimal128

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = Decimal128>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Copy for Decimal128