Struct Decimal 

pub struct Decimal { /* private fields */ }

Decimal represents a 128 bit representation of a fixed-precision decimal number. The finite set of values of type Decimal are of the form m / 10^e, where m is an integer such that -2⁹⁶ < m < 2⁹⁶, and e is an integer between 0 and 28 inclusive.

Implementations

impl Decimal

pub const MIN: Decimal = MIN

Available on non-crate feature bigdecimal only.

The smallest value that can be represented by this decimal type.

Examples

Basic usage:

assert_eq!(Decimal::MIN, dec!(-79_228_162_514_264_337_593_543_950_335));

pub const MAX: Decimal = MAX

Available on non-crate feature bigdecimal only.

The largest value that can be represented by this decimal type.

Examples

Basic usage:

assert_eq!(Decimal::MAX, dec!(79_228_162_514_264_337_593_543_950_335));

pub const ZERO: Decimal = ZERO

Available on non-crate feature bigdecimal only.

A constant representing 0.

Examples

Basic usage:

assert_eq!(Decimal::ZERO, dec!(0));

pub const ONE: Decimal = ONE

Available on non-crate feature bigdecimal only.

A constant representing 1.

Examples

Basic usage:

assert_eq!(Decimal::ONE, dec!(1));

pub const NEGATIVE_ONE: Decimal = NEGATIVE_ONE

Available on non-crate feature bigdecimal only.

A constant representing -1.

Examples

Basic usage:

assert_eq!(Decimal::NEGATIVE_ONE, dec!(-1));

pub const TWO: Decimal = TWO

Available on non-crate feature bigdecimal only.

A constant representing 2.

Examples

Basic usage:

assert_eq!(Decimal::TWO, dec!(2));

pub const TEN: Decimal = TEN

Available on non-crate feature bigdecimal only.

A constant representing 10.

Examples

Basic usage:

assert_eq!(Decimal::TEN, dec!(10));

pub const ONE_HUNDRED: Decimal = ONE_HUNDRED

Available on non-crate feature bigdecimal only.

A constant representing 100.

Examples

Basic usage:

assert_eq!(Decimal::ONE_HUNDRED, dec!(100));

pub const ONE_THOUSAND: Decimal = ONE_THOUSAND

Available on non-crate feature bigdecimal only.

A constant representing 1000.

Examples

Basic usage:

assert_eq!(Decimal::ONE_THOUSAND, dec!(1000));

pub const MAX_SCALE: u32 = MAX_SCALE_U32

Available on non-crate feature bigdecimal only.

The maximum supported scale value.

Some operations, such as Self::rescale may accept larger scale values, but these operations will result in a final value with a scale no larger than this.

Note that the maximum scale is not the same as the maximum possible numeric precision in base-10.

pub fn new(num: i64, scale: u32) -> Decimal

Available on non-crate feature bigdecimal only.

Returns a Decimal with a 64 bit m representation and corresponding e scale.

Arguments

• num - An i64 that represents the m portion of the decimal number
• scale - A u32 representing the e portion of the decimal number.

Panics

This function panics if scale is > Self::MAX_SCALE.

Example

let pi = Decimal::new(3141, 3);
assert_eq!(pi.to_string(), "3.141");

pub const fn try_new(num: i64, scale: u32) -> Result<Decimal, Error>

Available on non-crate feature bigdecimal only.

Checked version of Self::new. Will return an error instead of panicking at run-time.

Example

let max = Decimal::try_new(i64::MAX, u32::MAX);
assert!(max.is_err());

pub fn from_i128_with_scale(num: i128, scale: u32) -> Decimal

Available on non-crate feature bigdecimal only.

Creates a Decimal using a 128 bit signed m representation and corresponding e scale.

Arguments

• num - An i128 that represents the m portion of the decimal number
• scale - A u32 representing the e portion of the decimal number.

Panics

This function panics if scale is > Self::MAX_SCALE or if num exceeds the maximum supported 96 bits.

Example

let pi = Decimal::from_i128_with_scale(3141i128, 3);
assert_eq!(pi.to_string(), "3.141");

pub const fn try_from_i128_with_scale( num: i128, scale: u32, ) -> Result<Decimal, Error>

Available on non-crate feature bigdecimal only.

Checked version of Decimal::from_i128_with_scale. Will return Err instead of panicking at run-time.

Example

let max = Decimal::try_from_i128_with_scale(i128::MAX, u32::MAX);
assert!(max.is_err());

pub const fn from_parts( lo: u32, mid: u32, hi: u32, negative: bool, scale: u32, ) -> Decimal

Available on non-crate feature bigdecimal only.

Returns a Decimal using the instances constituent parts.

Arguments

• lo - The low 32 bits of a 96-bit integer.
• mid - The middle 32 bits of a 96-bit integer.
• hi - The high 32 bits of a 96-bit integer.
• negative - true to indicate a negative number.
• scale - A power of 10 ranging from 0 to Self::MAX_SCALE.

Example

let pi = Decimal::from_parts(1102470952, 185874565, 1703060790, false, 28);
assert_eq!(pi.to_string(), "3.1415926535897932384626433832");

pub fn from_scientific(value: &str) -> Result<Decimal, Error>

Available on non-crate feature bigdecimal only.

Returns a Result which if successful contains the Decimal constitution of the scientific notation provided by value.

Arguments

• value - The scientific notation of the Decimal.

Example

let value = Decimal::from_scientific("9.7e-7")?;
assert_eq!(value.to_string(), "0.00000097");

pub fn from_scientific_lossy(value: &str) -> Result<Decimal, Error>

Available on non-crate feature bigdecimal only.

Returns a Result which if successful contains the Decimal constitution of the scientific notation provided by value. If the exponent is negative and the given base and exponent would exceed Decimal::MAX_SCALE then this functions attempts to round the base to fit.

Arguments

• value - The scientific notation of the Decimal.

Example

let value = Decimal::from_scientific_lossy("2.710505431213761e-20")?;
assert_eq!(value.to_string(), "0.0000000000000000000271050543");

let value = Decimal::from_scientific_lossy("2.5e-28")?;
assert_eq!(value.to_string(), "0.0000000000000000000000000003");

let value = Decimal::from_scientific_lossy("-2.5e-28")?;
assert_eq!(value.to_string(), "-0.0000000000000000000000000003");

let err = Decimal::from_scientific_lossy("2e-29").unwrap_err();
assert_eq!(err, Error::ScaleExceedsMaximumPrecision(29));

pub fn from_str_radix(str: &str, radix: u32) -> Result<Decimal, Error>

Available on non-crate feature bigdecimal only.

Converts a string slice in a given base to a decimal.

The string is expected to be an optional + sign followed by digits. Digits are a subset of these characters, depending on radix, and will return an error if outside the expected range:

• 0-9
• a-z
• A-Z

Examples

Basic usage:

assert_eq!(Decimal::from_str_radix("A", 16)?.to_string(), "10");

pub fn from_str_exact(str: &str) -> Result<Decimal, Error>

Available on non-crate feature bigdecimal only.

Parses a string slice into a decimal. If the value underflows and cannot be represented with the given scale then this will return an error.

Examples

Basic usage:

assert_eq!(Decimal::from_str_exact("0.001")?.to_string(), "0.001");
assert_eq!(Decimal::from_str_exact("0.00000_00000_00000_00000_00000_001")?.to_string(), "0.0000000000000000000000000001");
assert_eq!(Decimal::from_str_exact("0.00000_00000_00000_00000_00000_0001"), Err(Error::Underflow));

pub fn array_string(&self) -> impl AsRef<str>

Available on non-crate feature bigdecimal only.

Returns a string representation that is similar to alloc::string::ToString but doesn’t require a heap allocation.

Examples

assert_eq!(Decimal::from_str_exact("0.001")?.array_string().as_ref(), "0.001");

pub const fn scale(&self) -> u32

Available on non-crate feature bigdecimal only.

Returns the scale of the decimal number, otherwise known as e.

Example

let num = Decimal::new(1234, 3);
assert_eq!(num.scale(), 3u32);

pub const fn mantissa(&self) -> i128

Available on non-crate feature bigdecimal only.

Returns the mantissa of the decimal number.

Example

let num = dec!(-1.2345678);
assert_eq!(num.mantissa(), -12345678i128);
assert_eq!(num.scale(), 7);

pub const fn is_zero(&self) -> bool

Available on non-crate feature bigdecimal only.

Returns true if this Decimal number is equivalent to zero.

Example

let num = Decimal::ZERO;
assert!(num.is_zero());

pub fn is_integer(&self) -> bool

Available on non-crate feature bigdecimal only.

Returns true if this Decimal number has zero fractional part (is equal to an integer)

Example

assert_eq!(dec!(5).is_integer(), true);
// Trailing zeros are also ignored
assert_eq!(dec!(5.0000).is_integer(), true);
// If there is a fractional part then it is not an integer
assert_eq!(dec!(5.1).is_integer(), false);

pub fn set_sign(&mut self, positive: bool)

👎Deprecated since 1.4.0:

please use set_sign_positive instead

Available on non-crate feature bigdecimal only.

An optimized method for changing the sign of a decimal number.

Arguments

• positive: true if the resulting decimal should be positive.

Example

let mut one = Decimal::ONE;
one.set_sign(false);
assert_eq!(one.to_string(), "-1");

pub fn set_sign_positive(&mut self, positive: bool)

Available on non-crate feature bigdecimal only.

An optimized method for changing the sign of a decimal number.

Arguments

• positive: true if the resulting decimal should be positive.

Example

let mut one = Decimal::ONE;
one.set_sign_positive(false);
assert_eq!(one.to_string(), "-1");

pub fn set_sign_negative(&mut self, negative: bool)

Available on non-crate feature bigdecimal only.

An optimized method for changing the sign of a decimal number.

Arguments

• negative: true if the resulting decimal should be negative.

Example

let mut one = Decimal::ONE;
one.set_sign_negative(true);
assert_eq!(one.to_string(), "-1");

pub fn set_scale(&mut self, scale: u32) -> Result<(), Error>

Available on non-crate feature bigdecimal only.

An optimized method for changing the scale of a decimal number.

Arguments

• scale: the new scale of the number

Example

let mut one = Decimal::ONE;
one.set_scale(5)?;
assert_eq!(one.to_string(), "0.00001");

pub fn rescale(&mut self, scale: u32)

Available on non-crate feature bigdecimal only.

Modifies the Decimal towards the desired scale, attempting to do so without changing the underlying number itself.

Setting the scale to something less then the current Decimals scale will cause the newly created Decimal to perform rounding using the MidpointAwayFromZero strategy.

Scales greater than the maximum precision that can be represented by Decimal will be automatically rounded to either Self::MAX_SCALE or the maximum precision that can be represented with the given mantissa.

Arguments

• scale: The desired scale to use for the new Decimal number.

Example

// Rescaling to a higher scale preserves the value
let mut number = dec!(1.123);
assert_eq!(number.scale(), 3);
number.rescale(6);
assert_eq!(number.to_string(), "1.123000");
assert_eq!(number.scale(), 6);

// Rescaling to a lower scale forces the number to be rounded
let mut number = dec!(1.45);
assert_eq!(number.scale(), 2);
number.rescale(1);
assert_eq!(number.to_string(), "1.5");
assert_eq!(number.scale(), 1);

// This function never fails. Consequently, if a scale is provided that is unable to be
// represented using the given mantissa, then the maximum possible scale is used.
let mut number = dec!(11.76470588235294);
assert_eq!(number.scale(), 14);
number.rescale(28);
// A scale of 28 cannot be represented given this mantissa, however it was able to represent
// a number with a scale of 27
assert_eq!(number.to_string(), "11.764705882352940000000000000");
assert_eq!(number.scale(), 27);

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

Available on non-crate feature bigdecimal only.

Returns a serialized version of the decimal number. The resulting byte array will have the following representation:

• Bytes 1-4: flags
• Bytes 5-8: lo portion of m
• Bytes 9-12: mid portion of m
• Bytes 13-16: high portion of m

pub fn deserialize(bytes: [u8; 16]) -> Decimal

Available on non-crate feature bigdecimal only.

Deserializes the given bytes into a decimal number. The deserialized byte representation must be 16 bytes and adhere to the following convention:

• Bytes 1-4: flags
• Bytes 5-8: lo portion of m
• Bytes 9-12: mid portion of m
• Bytes 13-16: high portion of m

pub fn is_negative(&self) -> bool

👎Deprecated since 0.6.3:

please use is_sign_negative instead

Available on non-crate feature bigdecimal only.

Returns true if the decimal is negative.

pub fn is_positive(&self) -> bool

👎Deprecated since 0.6.3:

please use is_sign_positive instead

Available on non-crate feature bigdecimal only.

Returns true if the decimal is positive.

pub const fn is_sign_negative(&self) -> bool

Available on non-crate feature bigdecimal only.

Returns true if the sign bit of the decimal is negative.

Example

assert_eq!(true, Decimal::new(-1, 0).is_sign_negative());
assert_eq!(false, Decimal::new(1, 0).is_sign_negative());

pub const fn is_sign_positive(&self) -> bool

Available on non-crate feature bigdecimal only.

Returns true if the sign bit of the decimal is positive.

Example

assert_eq!(false, Decimal::new(-1, 0).is_sign_positive());
assert_eq!(true, Decimal::new(1, 0).is_sign_positive());

pub const fn min_value() -> Decimal

👎Deprecated since 1.12.0:

Use the associated constant Decimal::MIN

Available on non-crate feature bigdecimal only.

Returns the minimum possible number that Decimal can represent.

pub const fn max_value() -> Decimal

👎Deprecated since 1.12.0:

Use the associated constant Decimal::MAX

Available on non-crate feature bigdecimal only.

Returns the maximum possible number that Decimal can represent.

pub fn trunc(&self) -> Decimal

Available on non-crate feature bigdecimal only.

Returns a new Decimal integral with no fractional portion. This is a true truncation whereby no rounding is performed.

Example

let pi = dec!(3.141);
assert_eq!(pi.trunc(), dec!(3));

// Negative numbers are similarly truncated without rounding
let neg = dec!(-1.98765);
assert_eq!(neg.trunc(), Decimal::NEGATIVE_ONE);

pub fn trunc_with_scale(&self, scale: u32) -> Decimal

Available on non-crate feature bigdecimal only.

Returns a new Decimal with the fractional portion delimited by scale. This is a true truncation whereby no rounding is performed.

Example

let pi = dec!(3.141592);
assert_eq!(pi.trunc_with_scale(2), dec!(3.14));

// Negative numbers are similarly truncated without rounding
let neg = dec!(-1.98765);
assert_eq!(neg.trunc_with_scale(1), dec!(-1.9));

pub fn fract(&self) -> Decimal

Available on non-crate feature bigdecimal only.

Returns a new Decimal representing the fractional portion of the number.

Example

let pi = Decimal::new(3141, 3);
let fract = Decimal::new(141, 3);
// note that it returns a decimal
assert_eq!(pi.fract(), fract);

pub fn abs(&self) -> Decimal

Available on non-crate feature bigdecimal only.

Computes the absolute value of self.

Example

let num = Decimal::new(-3141, 3);
assert_eq!(num.abs().to_string(), "3.141");

pub fn floor(&self) -> Decimal

Available on non-crate feature bigdecimal only.

Returns the largest integer less than or equal to a number.

Example

let num = Decimal::new(3641, 3);
assert_eq!(num.floor().to_string(), "3");

pub fn ceil(&self) -> Decimal

Available on non-crate feature bigdecimal only.

Returns the smallest integer greater than or equal to a number.

Example

let num = Decimal::new(3141, 3);
assert_eq!(num.ceil().to_string(), "4");
let num = Decimal::new(3, 0);
assert_eq!(num.ceil().to_string(), "3");

pub fn max(self, other: Decimal) -> Decimal

Available on non-crate feature bigdecimal only.

Returns the maximum of the two numbers.

let x = Decimal::new(1, 0);
let y = Decimal::new(2, 0);
assert_eq!(y, x.max(y));

pub fn min(self, other: Decimal) -> Decimal

Available on non-crate feature bigdecimal only.

Returns the minimum of the two numbers.

let x = Decimal::new(1, 0);
let y = Decimal::new(2, 0);
assert_eq!(x, x.min(y));

pub fn normalize(&self) -> Decimal

Available on non-crate feature bigdecimal only.

Strips any trailing zero’s from a Decimal and converts -0 to 0.

Example

let number = Decimal::from_str("3.100")?;
assert_eq!(number.normalize().to_string(), "3.1");

pub fn normalize_assign(&mut self)

Available on non-crate feature bigdecimal only.

An in place version of normalize. Strips any trailing zero’s from a Decimal and converts -0 to 0.

Example

let mut number = Decimal::from_str("3.100")?;
assert_eq!(number.to_string(), "3.100");
number.normalize_assign();
assert_eq!(number.to_string(), "3.1");

pub fn round(&self) -> Decimal

Available on non-crate feature bigdecimal only.

Returns a new Decimal number with no fractional portion (i.e. an integer). Rounding currently follows “Bankers Rounding” rules. e.g. 6.5 -> 6, 7.5 -> 8

Example

// Demonstrating bankers rounding...
let number_down = Decimal::new(65, 1);
let number_up   = Decimal::new(75, 1);
assert_eq!(number_down.round().to_string(), "6");
assert_eq!(number_up.round().to_string(), "8");

pub fn round_dp_with_strategy( &self, dp: u32, strategy: RoundingStrategy, ) -> Decimal

Available on non-crate feature bigdecimal only.

Returns a new Decimal number with the specified number of decimal points for fractional portion. Rounding is performed using the provided RoundingStrategy

Arguments

• dp: the number of decimal points to round to.
• strategy: the RoundingStrategy to use.

Example

let tax = dec!(3.4395);
assert_eq!(tax.round_dp_with_strategy(2, RoundingStrategy::MidpointAwayFromZero).to_string(), "3.44");

pub fn round_dp(&self, dp: u32) -> Decimal

Available on non-crate feature bigdecimal only.

Returns a new Decimal number with the specified number of decimal points for fractional portion. Rounding currently follows “Bankers Rounding” rules. e.g. 6.5 -> 6, 7.5 -> 8

Arguments

• dp: the number of decimal points to round to.

Example

let pi = dec!(3.1415926535897932384626433832);
assert_eq!(pi.round_dp(2).to_string(), "3.14");

pub fn round_sf(&self, digits: u32) -> Option<Decimal>

Available on non-crate feature bigdecimal only.

Returns Some(Decimal) number rounded to the specified number of significant digits. If the resulting number is unable to be represented by the Decimal number then None will be returned. When the number of significant figures of the Decimal being rounded is greater than the requested number of significant digits then rounding will be performed using MidpointNearestEven strategy.

Arguments

• digits: the number of significant digits to round to.

Remarks

A significant figure is determined using the following rules:

1. Non-zero digits are always significant.
2. Zeros between non-zero digits are always significant.
3. Leading zeros are never significant.
4. Trailing zeros are only significant if the number contains a decimal point.

Example

let value = dec!(305.459);
assert_eq!(value.round_sf(0), Some(dec!(0)));
assert_eq!(value.round_sf(1), Some(dec!(300)));
assert_eq!(value.round_sf(2), Some(dec!(310)));
assert_eq!(value.round_sf(3), Some(dec!(305)));
assert_eq!(value.round_sf(4), Some(dec!(305.5)));
assert_eq!(value.round_sf(5), Some(dec!(305.46)));
assert_eq!(value.round_sf(6), Some(dec!(305.459)));
assert_eq!(value.round_sf(7), Some(dec!(305.4590)));
assert_eq!(Decimal::MAX.round_sf(1), None);

let value = dec!(0.012301);
assert_eq!(value.round_sf(3), Some(dec!(0.0123)));

pub fn round_sf_with_strategy( &self, digits: u32, strategy: RoundingStrategy, ) -> Option<Decimal>

Available on non-crate feature bigdecimal only.

Returns Some(Decimal) number rounded to the specified number of significant digits. If the resulting number is unable to be represented by the Decimal number then None will be returned. When the number of significant figures of the Decimal being rounded is greater than the requested number of significant digits then rounding will be performed using the provided RoundingStrategy.

Arguments

• digits: the number of significant digits to round to.
• strategy: if required, the rounding strategy to use.

Remarks

A significant figure is determined using the following rules:

1. Non-zero digits are always significant.
2. Zeros between non-zero digits are always significant.
3. Leading zeros are never significant.
4. Trailing zeros are only significant if the number contains a decimal point.

Example

let value = dec!(305.459);
assert_eq!(value.round_sf_with_strategy(0, RoundingStrategy::ToZero), Some(dec!(0)));
assert_eq!(value.round_sf_with_strategy(1, RoundingStrategy::ToZero), Some(dec!(300)));
assert_eq!(value.round_sf_with_strategy(2, RoundingStrategy::ToZero), Some(dec!(300)));
assert_eq!(value.round_sf_with_strategy(3, RoundingStrategy::ToZero), Some(dec!(305)));
assert_eq!(value.round_sf_with_strategy(4, RoundingStrategy::ToZero), Some(dec!(305.4)));
assert_eq!(value.round_sf_with_strategy(5, RoundingStrategy::ToZero), Some(dec!(305.45)));
assert_eq!(value.round_sf_with_strategy(6, RoundingStrategy::ToZero), Some(dec!(305.459)));
assert_eq!(value.round_sf_with_strategy(7, RoundingStrategy::ToZero), Some(dec!(305.4590)));
assert_eq!(Decimal::MAX.round_sf_with_strategy(1, RoundingStrategy::ToZero), Some(dec!(70000000000000000000000000000)));

let value = dec!(0.012301);
assert_eq!(value.round_sf_with_strategy(3, RoundingStrategy::AwayFromZero), Some(dec!(0.0124)));

pub const fn unpack(&self) -> UnpackedDecimal

Available on non-crate feature bigdecimal only.

Convert Decimal to an internal representation of the underlying struct. This is useful for debugging the internal state of the object.

Important Disclaimer

This is primarily intended for library maintainers. The internal representation of a Decimal is considered “unstable” for public use.

Example

let pi = dec!(3.1415926535897932384626433832);
assert_eq!(format!("{:?}", pi), "3.1415926535897932384626433832");
assert_eq!(format!("{:?}", pi.unpack()), "UnpackedDecimal { \
    negative: false, scale: 28, hi: 1703060790, mid: 185874565, lo: 1102470952 \
}");

pub fn from_f32_retain(n: f32) -> Option<Decimal>

Available on non-crate feature bigdecimal only.

Parses a 32-bit float into a Decimal number whilst retaining any non-guaranteed precision.

Typically when a float is parsed in Rust Decimal, any excess bits (after ~7.22 decimal points for f32 as per IEEE-754) are removed due to any digits following this are considered an approximation at best. This function bypasses this additional step and retains these excess bits.

Example

// Usually floats are parsed leveraging float guarantees. i.e. 0.1_f32 => 0.1
assert_eq!("0.1", Decimal::from_f32(0.1_f32).unwrap().to_string());

// Sometimes, we may want to represent the approximation exactly.
assert_eq!("0.100000001490116119384765625", Decimal::from_f32_retain(0.1_f32).unwrap().to_string());

pub fn from_f64_retain(n: f64) -> Option<Decimal>

Available on non-crate feature bigdecimal only.

Parses a 64-bit float into a Decimal number whilst retaining any non-guaranteed precision.

Typically when a float is parsed in Rust Decimal, any excess bits (after ~15.95 decimal points for f64 as per IEEE-754) are removed due to any digits following this are considered an approximation at best. This function bypasses this additional step and retains these excess bits.

Example

// Usually floats are parsed leveraging float guarantees. i.e. 0.1_f64 => 0.1
assert_eq!("0.1", Decimal::from_f64(0.1_f64).unwrap().to_string());

// Sometimes, we may want to represent the approximation exactly.
assert_eq!("0.1000000000000000055511151231", Decimal::from_f64_retain(0.1_f64).unwrap().to_string());

impl Decimal

pub fn as_i128(&self) -> i128

Available on non-crate feature bigdecimal only.

Converts this Decimal to an i128, truncating any fractional part.

This is the infallible equivalent of ToPrimitive::to_i128.

pub fn as_f64(&self) -> f64

Available on non-crate feature bigdecimal only.

Converts this Decimal to an f64.

This is the infallible equivalent of ToPrimitive::to_f64.

impl Decimal

pub fn checked_add(self, other: Decimal) -> Option<Decimal>

Available on non-crate feature bigdecimal only.

Checked addition. Computes self + other, returning None if overflow occurred.

pub fn saturating_add(self, other: Decimal) -> Decimal

Available on non-crate feature bigdecimal only.

Saturating addition. Computes self + other, saturating at the relevant upper or lower boundary.

pub fn checked_mul(self, other: Decimal) -> Option<Decimal>

Available on non-crate feature bigdecimal only.

Checked multiplication. Computes self * other, returning None if overflow occurred.

pub fn saturating_mul(self, other: Decimal) -> Decimal

Available on non-crate feature bigdecimal only.

Saturating multiplication. Computes self * other, saturating at the relevant upper or lower boundary.

pub fn checked_sub(self, other: Decimal) -> Option<Decimal>

Available on non-crate feature bigdecimal only.

Checked subtraction. Computes self - other, returning None if overflow occurred.

pub fn saturating_sub(self, other: Decimal) -> Decimal

Available on non-crate feature bigdecimal only.

Saturating subtraction. Computes self - other, saturating at the relevant upper or lower boundary.

pub fn checked_div(self, other: Decimal) -> Option<Decimal>

Available on non-crate feature bigdecimal only.

Checked division. Computes self / other, returning None if overflow occurred.

pub fn checked_rem(self, other: Decimal) -> Option<Decimal>

Available on non-crate feature bigdecimal only.

Checked remainder. Computes self % other, returning None if overflow occurred.

Trait Implementations

impl Add for Decimal

type Output = Decimal

The resulting type after applying the + operator.

fn add(self, other: Decimal) -> Decimal

Performs the + operation.

impl<'a> Add<&'a Decimal> for Decimal

type Output = Decimal

The resulting type after applying the + operator.

fn add(self, other: &Decimal) -> Decimal

Performs the + operation.

impl Add<&Decimal> for &Decimal

type Output = Decimal

The resulting type after applying the + operator.

fn add(self, other: &Decimal) -> Decimal

Performs the + operation.

impl<'a> Add<Decimal> for &'a Decimal

type Output = Decimal

The resulting type after applying the + operator.

fn add(self, other: Decimal) -> Decimal

Performs the + operation.

impl AddAssign for Decimal

fn add_assign(&mut self, other: Decimal)

Performs the += operation.

impl<'a> AddAssign<&'a Decimal> for &'a mut Decimal

fn add_assign(&mut self, other: &'a Decimal)

Performs the += operation.

impl<'a> AddAssign<&'a Decimal> for Decimal

fn add_assign(&mut self, other: &'a Decimal)

Performs the += operation.

impl AddAssign<Decimal> for &mut Decimal

fn add_assign(&mut self, other: Decimal)

Performs the += operation.

impl AsRef<Decimal> for NonNegativeDecimal

fn as_ref(&self) -> &Decimal

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Decimal> for PositiveDecimal

fn as_ref(&self) -> &Decimal

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Decimal> for Ratio

fn as_ref(&self) -> &Decimal

Converts this type into a shared reference of the (usually inferred) input type.

impl CheckedAdd for Decimal

fn checked_add(&self, v: &Decimal) -> Option<Decimal>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl CheckedDiv for Decimal

fn checked_div(&self, v: &Decimal) -> Option<Decimal>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl CheckedMul for Decimal

fn checked_mul(&self, v: &Decimal) -> Option<Decimal>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl CheckedRem for Decimal

fn checked_rem(&self, v: &Decimal) -> Option<Decimal>

Finds the remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl CheckedSub for Decimal

fn checked_sub(&self, v: &Decimal) -> Option<Decimal>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl Clone for Decimal

fn clone(&self) -> Decimal

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Decimal

impl Debug for Decimal

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

Formats the value using the given formatter.

impl Decimal128Mantissa for Decimal

fn try_to_i128_mantissa(&self, target_scale: u32) -> Option<i128>

Returns the mantissa after rescaling to target_scale, or None when the result exceeds decimal128 precision or the active backend cannot represent the conversion.

impl Default for Decimal

fn default() -> Decimal

Returns the default value for a Decimal (equivalent to Decimal::ZERO).

impl<'de> Deserialize<'de> for Decimal

Available on non-crate feature serde-str only.

fn deserialize<D>( deserializer: D, ) -> Result<Decimal, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Decimal

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

Formats the value using the given formatter.

impl Div for Decimal

type Output = Decimal

The resulting type after applying the / operator.

fn div(self, other: Decimal) -> Decimal

Performs the / operation.

impl<'a> Div<&'a Decimal> for Decimal

type Output = Decimal

The resulting type after applying the / operator.

fn div(self, other: &Decimal) -> Decimal

Performs the / operation.

impl Div<&Decimal> for &Decimal

type Output = Decimal

The resulting type after applying the / operator.

fn div(self, other: &Decimal) -> Decimal

Performs the / operation.

impl<'a> Div<Decimal> for &'a Decimal

type Output = Decimal

The resulting type after applying the / operator.

fn div(self, other: Decimal) -> Decimal

Performs the / operation.

impl DivAssign for Decimal

fn div_assign(&mut self, other: Decimal)

Performs the /= operation.

impl<'a> DivAssign<&'a Decimal> for &'a mut Decimal

fn div_assign(&mut self, other: &'a Decimal)

Performs the /= operation.

impl<'a> DivAssign<&'a Decimal> for Decimal

fn div_assign(&mut self, other: &'a Decimal)

Performs the /= operation.

impl DivAssign<Decimal> for &mut Decimal

fn div_assign(&mut self, other: Decimal)

Performs the /= operation.

impl Eq for Decimal

impl From<NonNegativeDecimal> for Decimal

fn from(value: NonNegativeDecimal) -> Self

Converts to this type from the input type.

impl From<PositiveDecimal> for Decimal

fn from(value: PositiveDecimal) -> Self

Converts to this type from the input type.

impl From<Ratio> for Decimal

fn from(value: Ratio) -> Self

Converts to this type from the input type.

impl From<UnpackedDecimal> for Decimal

fn from(value: UnpackedDecimal) -> Decimal

Converts to this type from the input type.

impl From<i8> for Decimal

Conversion to Decimal.

fn from(t: i8) -> Decimal

Converts to this type from the input type.

impl From<i16> for Decimal

Conversion to Decimal.

fn from(t: i16) -> Decimal

Converts to this type from the input type.

impl From<i32> for Decimal

Conversion to Decimal.

fn from(t: i32) -> Decimal

Converts to this type from the input type.

impl From<i64> for Decimal

Conversion to Decimal.

fn from(t: i64) -> Decimal

Converts to this type from the input type.

impl From<i128> for Decimal

Conversion to Decimal.

fn from(t: i128) -> Decimal

Converts to this type from the input type.

impl From<isize> for Decimal

Conversion to Decimal.

fn from(t: isize) -> Decimal

Converts to this type from the input type.

impl From<u8> for Decimal

Conversion to Decimal.

fn from(t: u8) -> Decimal

Converts to this type from the input type.

impl From<u16> for Decimal

Conversion to Decimal.

fn from(t: u16) -> Decimal

Converts to this type from the input type.

impl From<u32> for Decimal

Conversion to Decimal.

fn from(t: u32) -> Decimal

Converts to this type from the input type.

impl From<u64> for Decimal

Conversion to Decimal.

fn from(t: u64) -> Decimal

Converts to this type from the input type.

impl From<u128> for Decimal

Conversion to Decimal.

fn from(t: u128) -> Decimal

Converts to this type from the input type.

impl From<usize> for Decimal

Conversion to Decimal.

fn from(t: usize) -> Decimal

Converts to this type from the input type.

impl FromPrimitive for Decimal

fn from_i32(n: i32) -> Option<Decimal>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i64(n: i64) -> Option<Decimal>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Decimal>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Decimal>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<Decimal>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Decimal>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Decimal>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Decimal>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl FromStr for Decimal

type Err = Error

The associated error which can be returned from parsing.

fn from_str(value: &str) -> Result<Decimal, <Decimal as FromStr>::Err>

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

impl Hash for Decimal

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Inv for Decimal

type Output = Decimal

The result after applying the operator.

fn inv(self) -> Decimal

Returns the multiplicative inverse of self.

impl LowerExp for Decimal

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

Formats the value using the given formatter.

impl Mul for Decimal

type Output = Decimal

The resulting type after applying the * operator.

fn mul(self, other: Decimal) -> Decimal

Performs the * operation.

impl<'a> Mul<&'a Decimal> for Decimal

type Output = Decimal

The resulting type after applying the * operator.

fn mul(self, other: &Decimal) -> Decimal

Performs the * operation.

impl Mul<&Decimal> for &Decimal

type Output = Decimal

The resulting type after applying the * operator.

fn mul(self, other: &Decimal) -> Decimal

Performs the * operation.

impl<'a> Mul<Decimal> for &'a Decimal

type Output = Decimal

The resulting type after applying the * operator.

fn mul(self, other: Decimal) -> Decimal

Performs the * operation.

impl MulAssign for Decimal

fn mul_assign(&mut self, other: Decimal)

Performs the *= operation.

impl<'a> MulAssign<&'a Decimal> for &'a mut Decimal

fn mul_assign(&mut self, other: &'a Decimal)

Performs the *= operation.

impl<'a> MulAssign<&'a Decimal> for Decimal

fn mul_assign(&mut self, other: &'a Decimal)

Performs the *= operation.

impl MulAssign<Decimal> for &mut Decimal

fn mul_assign(&mut self, other: Decimal)

Performs the *= operation.

impl Neg for &Decimal

type Output = Decimal

The resulting type after applying the - operator.

fn neg(self) -> Decimal

Performs the unary - operation.

impl Neg for Decimal

type Output = Decimal

The resulting type after applying the - operator.

fn neg(self) -> Decimal

Performs the unary - operation.

impl Num for Decimal

type FromStrRadixErr = Error

fn from_str_radix( str: &str, radix: u32, ) -> Result<Decimal, <Decimal as Num>::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl One for Decimal

fn one() -> Decimal

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl Ord for Decimal

fn cmp(&self, other: &Decimal) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Decimal

fn eq(&self, other: &Decimal) -> 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 Decimal

fn partial_cmp(&self, other: &Decimal) -> 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 Product for Decimal

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

where I: Iterator<Item = Decimal>,

Panics if out-of-bounds

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

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

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

Panics if out-of-bounds

impl Rem for Decimal

type Output = Decimal

The resulting type after applying the % operator.

fn rem(self, other: Decimal) -> Decimal

Performs the % operation.

impl<'a> Rem<&'a Decimal> for Decimal

type Output = Decimal

The resulting type after applying the % operator.

fn rem(self, other: &Decimal) -> Decimal

Performs the % operation.

impl Rem<&Decimal> for &Decimal

type Output = Decimal

The resulting type after applying the % operator.

fn rem(self, other: &Decimal) -> Decimal

Performs the % operation.

impl<'a> Rem<Decimal> for &'a Decimal

type Output = Decimal

The resulting type after applying the % operator.

fn rem(self, other: Decimal) -> Decimal

Performs the % operation.

impl RemAssign for Decimal

fn rem_assign(&mut self, other: Decimal)

Performs the %= operation.

impl<'a> RemAssign<&'a Decimal> for &'a mut Decimal

fn rem_assign(&mut self, other: &'a Decimal)

Performs the %= operation.

impl<'a> RemAssign<&'a Decimal> for Decimal

fn rem_assign(&mut self, other: &'a Decimal)

Performs the %= operation.

impl RemAssign<Decimal> for &mut Decimal

fn rem_assign(&mut self, other: Decimal)

Performs the %= operation.

impl Serialize for Decimal

Available on non-crate feature serde-float only.

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Signed for Decimal

fn abs(&self) -> Decimal

Computes the absolute value.

fn abs_sub(&self, other: &Decimal) -> Decimal

The positive difference of two numbers.

fn signum(&self) -> Decimal

Returns the sign of the number.

fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

impl Sub for Decimal

type Output = Decimal

The resulting type after applying the - operator.

fn sub(self, other: Decimal) -> Decimal

Performs the - operation.

impl<'a> Sub<&'a Decimal> for Decimal

type Output = Decimal

The resulting type after applying the - operator.

fn sub(self, other: &Decimal) -> Decimal

Performs the - operation.

impl Sub<&Decimal> for &Decimal

type Output = Decimal

The resulting type after applying the - operator.

fn sub(self, other: &Decimal) -> Decimal

Performs the - operation.

impl<'a> Sub<Decimal> for &'a Decimal

type Output = Decimal

The resulting type after applying the - operator.

fn sub(self, other: Decimal) -> Decimal

Performs the - operation.

impl SubAssign for Decimal

fn sub_assign(&mut self, other: Decimal)

Performs the -= operation.

impl<'a> SubAssign<&'a Decimal> for &'a mut Decimal

fn sub_assign(&mut self, other: &'a Decimal)

Performs the -= operation.

impl<'a> SubAssign<&'a Decimal> for Decimal

fn sub_assign(&mut self, other: &'a Decimal)

Performs the -= operation.

impl SubAssign<Decimal> for &mut Decimal

fn sub_assign(&mut self, other: Decimal)

Performs the -= operation.

impl Sum for Decimal

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

where I: Iterator<Item = Decimal>,

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

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

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

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

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

impl ToPrimitive for Decimal

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

impl TryFrom<&str> for Decimal

Try to convert a &str into a Decimal.

Can fail if the value is out of range for Decimal.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(t: &str) -> Result<Decimal, Error>

Performs the conversion.

impl TryFrom<Decimal> for NonNegativeDecimal

type Error = DecimalConstraintError

The type returned in the event of a conversion error.

fn try_from(value: Decimal) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Decimal> for PositiveDecimal

type Error = DecimalConstraintError

The type returned in the event of a conversion error.

fn try_from(value: Decimal) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Decimal> for Ratio

type Error = DecimalConstraintError

The type returned in the event of a conversion error.

fn try_from(value: Decimal) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<f32> for Decimal

Try to convert a f32 into a Decimal.

Can fail if the value is out of range for Decimal.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(t: f32) -> Result<Decimal, Error>

Performs the conversion.

impl TryFrom<f64> for Decimal

Try to convert a f64 into a Decimal.

Can fail if the value is out of range for Decimal.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(t: f64) -> Result<Decimal, Error>

Performs the conversion.

impl UpperExp for Decimal

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

Formats the value using the given formatter.

impl Zero for Decimal

fn zero() -> Decimal

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.