Struct Decimal 

pub struct Decimal<I: UnderlyingInt>(/* private fields */);

The decimal type.

The I is the underlying integer type. It supports u128 only by now, and will support u64 and u32 in next version. They have aliases Dec128, Dec64 and Dec32 respectively.

Implementations

impl<I: UnderlyingInt> Decimal<I>

pub fn abs(self) -> Self

Computes the absolute value of self.

pub fn checked_add(self, right: Self) -> Option<Self>

Computes the addition.

Return None if overflow.

There may loss precision if the scales of the 2 operands differ too greatly. It’s a classic round-off errors. of floating-point calculation.

Examples:

use lean_decimal::Dec128;
let a = Dec128::from_parts(123, 2); // 1.23
let b = Dec128::from_parts(1, 4);   // 0.0001
let sum = Dec128::from_parts(12301, 4); // 1.2301
assert_eq!(a.checked_add(b).unwrap(), sum);

pub fn checked_sub(self, right: Self) -> Option<Self>

Computes the addition.

Return None if overflow.

There may loss precision if the scales of the 2 operands differ too greatly. It’s a classic round-off errors. of floating-point calculation.

Examples:

use lean_decimal::Dec128;
let a = Dec128::from_parts(123, 2); // 1.23
let b = Dec128::from_parts(1, 4);   // 0.0001
let diff = Dec128::from_parts(12299, 4); // 1.2299
assert_eq!(a.checked_sub(b).unwrap(), diff);

pub fn checked_mul(self, right: impl Into<Self>) -> Option<Self>

Computes the multiplication.

Return None if overflow.

The right oprand could be short integers or decimals.

Examples:

use lean_decimal::Dec128;
let a = Dec128::from_parts(123, 2); // 1.23
let b = Dec128::from_parts(1, 4);   // 0.0001
let prod = Dec128::from_parts(123, 6); // 0.000123
assert_eq!(a.checked_mul(b).unwrap(), prod);

// by integer
let prod = Dec128::from_parts(246, 2); // 2.46
assert_eq!(a.checked_mul(2).unwrap(), prod);

pub fn checked_div(self, right: impl Into<Self>) -> Option<Self>

Computes the division.

Return None if overflow or divied by zero.

The right oprand could be short integers or decimals.

Examples:

use lean_decimal::Dec128;
let a = Dec128::from_parts(123, 2); // 1.23
let b = Dec128::from_parts(1, 4);   // 0.0001
let q = Dec128::from_parts(12300, 0); // 12300
assert_eq!(a.checked_div(b).unwrap(), q);

// by integer
let q = Dec128::from_parts(615, 3); // 0.615
assert_eq!(a.checked_div(2).unwrap(), q);

pub fn round_to(self, dst_scale: u32) -> Self

Round to the @dst_scale. Keep @dst_scale fraction decimal fractions.

Do nothing if the original scale is not bigger than @dst_scale

Examples:

use lean_decimal::Dec128;
let a = Dec128::from_parts(12345678, 6); // 12.345678
let b = Dec128::from_parts(1235, 2);   // 12.35
assert_eq!(a.round_to(2), b);

impl<I: UnderlyingInt> Decimal<I>

pub fn is_zero(self) -> bool

Return if the number is zero.

pub fn is_positive(self) -> bool

Return if the number is positive.

pub fn is_negative(self) -> bool

Return if the number is negative.

impl<I: UnderlyingInt> Decimal<I>

pub const ZERO: Self

Zero.

pub const MAX: Self

The largest value. To be largest, the scale is 0, so this is an integer, 2^b - 1, where b is the mantissa bits, which is 121, 58, 27 for Dec128, Dec64 and Dec32 correspondingly.

pub const MIN: Self

The smallest value. It’s the negative of Self::MAX.

pub fn parts(self) -> (I::Signed, u32)

Deconstruct the decimal into signed mantissa and scale.

Examples:

use lean_decimal::Dec128;
use core::str::FromStr;

let d = Dec128::from_str("3.14").unwrap();
assert_eq!(d.parts(), (314, 2));

pub fn from_parts<S>(mantissa: S, scale: u32) -> Self

where S: Into<I::Signed>,

Construct a decimal from signed mantissa and scale.

Panic:

Panic if the mantissa or scale is out of range. Use Self::try_from_parts for the checked version.

Examples:

use lean_decimal::Dec128;
let d = Dec128::from_parts(314, 2);
assert_eq!(d.to_string(), "3.14");

pub fn try_from_parts<S>(mantissa: S, scale: u32) -> Option<Self>

where S: Into<I::Signed>,

Construct a decimal from signed mantissa and scale.

Return None if the mantissa or scale is out of range.

Examples:

use lean_decimal::Dec128;
let d = Dec128::try_from_parts(314, 2).unwrap();
assert_eq!(d.to_string(), "3.14");

let d = Dec128::try_from_parts(314, 99); // 99 is out of range
assert!(d.is_none());

pub const fn underlying(self) -> I

Return the underlying integer.

You should not try to decode this integer yourself. You should just hold this and load it later.

pub fn from_underlying(ui: I) -> Self

Load from underlying integer, which should only be got from Self::underlying.

Panic:

Panic if invalid. Use Self::try_from_underlying for checked version.

pub fn try_from_underlying(ui: I) -> Option<Self>

Load from underlying integer, which should only be got from Self::underlying.

pub const unsafe fn unchecked_from_underlying(ui: I) -> Self

Load from underlying integer, which should only be got from Self::underlying.

SAFETY: It’s safe if you make sure the integer was got from Self::underlying.

Trait Implementations

impl<I: UnderlyingInt> Add for Decimal<I>

type Output = Decimal<I>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<I: UnderlyingInt> AddAssign for Decimal<I>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<I: Clone + UnderlyingInt> Clone for Decimal<I>

fn clone(&self) -> Decimal<I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: UnderlyingInt> Debug for Decimal<I>

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

Formats the value using the given formatter.

impl<I: Default + UnderlyingInt> Default for Decimal<I>

fn default() -> Decimal<I>

Returns the “default value” for a type.

impl<I: UnderlyingInt> Display for Decimal<I>

Display the decimal.

It supports some formatting options: width, fill, alignment, precision, sign and 0-fill.

Examples:

use lean_decimal::Dec128;
let d = Dec128::from_parts(12_3470, 4);

assert_eq!(format!("{}", d), "12.3470");
assert_eq!(format!("{:.6}", d), "12.347000"); // set precision: pad 0
assert_eq!(format!("{:.2}", d), "12.35"); // set smaller precision: round the number
assert_eq!(format!("{:x>10}", d), "xxx12.3470"); // set width, fill, alignment
assert_eq!(format!("{:+}", d), "+12.3470"); // set sign

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

Formats the value using the given formatter.

impl<I: UnderlyingInt, R: Into<Self>> Div<R> for Decimal<I>

type Output = Decimal<I>

The resulting type after applying the / operator.

fn div(self, rhs: R) -> Self::Output

Performs the / operation.

impl<I: UnderlyingInt, R: Into<Self>> DivAssign<R> for Decimal<I>

fn div_assign(&mut self, rhs: R)

Performs the /= operation.

impl From<i16> for Decimal<u128>

fn from(value: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Decimal<u128>

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Decimal<u128>

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<i8> for Decimal<u128>

fn from(value: i8) -> Self

Converts to this type from the input type.

impl From<u16> for Decimal<u128>

fn from(value: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Decimal<u128>

fn from(value: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Decimal<u128>

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Decimal<u128>

fn from(value: u8) -> Self

Converts to this type from the input type.

impl<I> FromStr for Decimal<I>

where I: UnderlyingInt + FromStr<Err = ParseIntError>,

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, ParseError>

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

impl<I: UnderlyingInt, R: Into<Self>> Mul<R> for Decimal<I>

type Output = Decimal<I>

The resulting type after applying the * operator.

fn mul(self, rhs: R) -> Self::Output

Performs the * operation.

impl<I: UnderlyingInt, R: Into<Self>> MulAssign<R> for Decimal<I>

fn mul_assign(&mut self, rhs: R)

Performs the *= operation.

impl<I: UnderlyingInt> Neg for Decimal<I>

type Output = Decimal<I>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<I: UnderlyingInt> Ord for Decimal<I>

fn cmp(&self, other: &Self) -> 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<I: UnderlyingInt> PartialEq for Decimal<I>

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<I: UnderlyingInt> PartialOrd for Decimal<I>

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<I: UnderlyingInt> Sub for Decimal<I>

type Output = Decimal<I>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<I: UnderlyingInt> SubAssign for Decimal<I>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<'a, I: UnderlyingInt> Sum<&'a Decimal<I>> for Decimal<I>

fn sum<Iter: Iterator<Item = &'a Self>>(iter: Iter) -> Self

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

impl<I: UnderlyingInt> Sum for Decimal<I>

fn sum<Iter: Iterator<Item = Self>>(iter: Iter) -> Self

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

impl<I: Copy + UnderlyingInt> Copy for Decimal<I>

impl<I: UnderlyingInt> Eq for Decimal<I>