# [−][src]Struct rust_decimal::Decimal

`pub struct Decimal { /* fields omitted */ }`

`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 / 10e, where m is an integer such that -296 < m < 296, and e is an integer between 0 and 28 inclusive.

## Methods

### `impl Decimal`[src]

#### `pub fn new(num: i64, scale: u32) -> Decimal`[src]

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.

# Example

```use rust_decimal::Decimal;

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

#### `pub const fn from_parts(    lo: u32,     mid: u32,     hi: u32,     negative: bool,     scale: u32) -> Decimal`[src]

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 28.

# Example

```use rust_decimal::Decimal;

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>`[src]

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

```use rust_decimal::Decimal;

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

#### `pub const fn scale(&self) -> u32`[src]

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

# Example

```use rust_decimal::Decimal;

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

#### `pub fn set_sign(&mut self, positive: bool)`[src]

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

# Arguments

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

# Example

```use rust_decimal::Decimal;

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

#### `pub fn set_scale(&mut self, scale: u32) -> Result<(), Error>`[src]

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

# Arguments

• `scale`: the new scale of the number

# Example

```use rust_decimal::Decimal;

let mut one = Decimal::new(1, 0);
one.set_scale(5);
assert_eq!(one.to_string(), "0.00001");```

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

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 const fn deserialize(bytes: [u8; 16]) -> Decimal`[src]

Deserializes the given bytes into a decimal number. The deserialized byte representation must be 16 bytes and adhere to the followign 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`[src]

Deprecated since 0.6.3:

please use `is_sign_negative` instead

Returns `true` if the decimal is negative.

#### `pub fn is_positive(&self) -> bool`[src]

Deprecated since 0.6.3:

please use `is_sign_positive` instead

Returns `true` if the decimal is positive.

#### `pub const fn is_sign_negative(&self) -> bool`[src]

Returns `true` if the decimal is negative.

#### `pub const fn is_sign_positive(&self) -> bool`[src]

Returns `true` if the decimal is positive.

#### `pub const fn min_value() -> Decimal`[src]

Returns the minimum possible number that `Decimal` can represent.

#### `pub const fn max_value() -> Decimal`[src]

Returns the maximum possible number that `Decimal` can represent.

#### `pub fn trunc(&self) -> Decimal`[src]

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

# Example

```use rust_decimal::Decimal;

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

#### `pub fn fract(&self) -> Decimal`[src]

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

# Example

```use rust_decimal::Decimal;

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`[src]

Computes the absolute value of `self`.

# Example

```use rust_decimal::Decimal;

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

#### `pub fn floor(&self) -> Decimal`[src]

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

# Example

```use rust_decimal::Decimal;

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

#### `pub fn ceil(&self) -> Decimal`[src]

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

# Example

```use rust_decimal::Decimal;

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 normalize(&self) -> Decimal`[src]

Strips any trailing zero's from a `Decimal`.

# Example

```use rust_decimal::Decimal;

let number = Decimal::new(3100, 3);
// note that it returns a decimal, without the extra scale
assert_eq!(number.normalize().to_string(), "3.1");```

#### `pub fn round(&self) -> Decimal`[src]

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

```use rust_decimal::Decimal;

// 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`[src]

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.

# Example

```use rust_decimal::{Decimal, RoundingStrategy};
use std::str::FromStr;

let tax = Decimal::from_str("3.4395").unwrap();
assert_eq!(tax.round_dp_with_strategy(2, RoundingStrategy::RoundHalfUp).to_string(), "3.44");```

#### `pub fn round_dp(&self, dp: u32) -> Decimal`[src]

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

```use rust_decimal::Decimal;
use std::str::FromStr;

let pi = Decimal::from_str("3.1415926535897932384626433832").unwrap();
assert_eq!(pi.round_dp(2).to_string(), "3.14");```

#### `pub const fn unpack(&self) -> UnpackedDecimal`[src]

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

```use rust_decimal::Decimal;
use std::str::FromStr;

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

#### `pub fn checked_add(self, other: Decimal) -> Option<Decimal>`[src]

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

#### `pub fn checked_sub(self, other: Decimal) -> Option<Decimal>`[src]

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

#### `pub fn checked_mul(self, other: Decimal) -> Option<Decimal>`[src]

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

#### `pub fn checked_div(self, other: Decimal) -> Option<Decimal>`[src]

Checked division. Computes `self / other`, returning `None` if `other == 0.0` or the division results in overflow.

#### `pub fn checked_rem(self, other: Decimal) -> Option<Decimal>`[src]

Checked remainder. Computes `self % other`, returning `None` if `other == 0.0`.

## Trait Implementations

### `impl Ord for Decimal`[src]

#### `fn max(self, other: Self) -> Self`1.21.0[src]

Compares and returns the maximum of two values. Read more

#### `fn min(self, other: Self) -> Self`1.21.0[src]

Compares and returns the minimum of two values. Read more

#### `fn clamp(self, min: Self, max: Self) -> Self`[src]

🔬 This is a nightly-only experimental API. (`clamp`)

Restrict a value to a certain interval. Read more

### `impl PartialOrd<Decimal> for Decimal`[src]

#### ```#[must_use] 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

#### ```#[must_use] 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

#### ```#[must_use] 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

#### ```#[must_use] 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 PartialEq<Decimal> for Decimal`[src]

#### ```#[must_use] fn ne(&self, other: &Rhs) -> bool```1.0.0[src]

This method tests for `!=`.

### `impl Clone for Decimal`[src]

#### `fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from `source`. Read more

### `impl Div<Decimal> for Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `/` operator.

### `impl<'a> Div<Decimal> for &'a Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `/` operator.

### `impl<'a> Div<&'a Decimal> for Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `/` operator.

### `impl<'a, 'b> Div<&'b Decimal> for &'a Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `/` operator.

### `impl Rem<Decimal> for Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `%` operator.

### `impl<'a> Rem<Decimal> for &'a Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `%` operator.

### `impl<'a> Rem<&'a Decimal> for Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `%` operator.

### `impl<'a, 'b> Rem<&'b Decimal> for &'a Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `%` operator.

### `impl FromStr for Decimal`[src]

#### `type Err = Error`

The associated error which can be returned from parsing.

### `impl Add<Decimal> for Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `+` operator.

### `impl<'a> Add<Decimal> for &'a Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `+` operator.

### `impl<'a> Add<&'a Decimal> for Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `+` operator.

### `impl<'a, 'b> Add<&'b Decimal> for &'a Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `+` operator.

### `impl Sub<Decimal> for Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `-` operator.

### `impl<'a> Sub<Decimal> for &'a Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `-` operator.

### `impl<'a> Sub<&'a Decimal> for Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `-` operator.

### `impl<'a, 'b> Sub<&'b Decimal> for &'a Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `-` operator.

### `impl Mul<Decimal> for Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `*` operator.

### `impl<'a> Mul<Decimal> for &'a Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `*` operator.

### `impl<'a> Mul<&'a Decimal> for Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `*` operator.

### `impl<'a, 'b> Mul<&'b Decimal> for &'a Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `*` operator.

### `impl Neg for Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `-` operator.

### `impl<'a> Neg for &'a Decimal`[src]

#### `type Output = Decimal`

The resulting type after applying the `-` operator.

### `impl Hash for Decimal`[src]

#### `fn hash_slice<H>(data: &[Self], state: &mut H) where    H: Hasher, `1.3.0[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

### `impl ToPrimitive for Decimal`[src]

#### `fn to_isize(&self) -> Option<isize>`[src]

Converts the value of `self` to an `isize`.

#### `fn to_i8(&self) -> Option<i8>`[src]

Converts the value of `self` to an `i8`.

#### `fn to_i16(&self) -> Option<i16>`[src]

Converts the value of `self` to an `i16`.

#### `fn to_i32(&self) -> Option<i32>`[src]

Converts the value of `self` to an `i32`.

#### `fn to_i128(&self) -> Option<i128>`[src]

Converts the value of `self` to an `i128`. Read more

#### `fn to_usize(&self) -> Option<usize>`[src]

Converts the value of `self` to a `usize`.

#### `fn to_u8(&self) -> Option<u8>`[src]

Converts the value of `self` to an `u8`.

#### `fn to_u16(&self) -> Option<u16>`[src]

Converts the value of `self` to an `u16`.

#### `fn to_u32(&self) -> Option<u32>`[src]

Converts the value of `self` to an `u32`.

#### `fn to_u128(&self) -> Option<u128>`[src]

Converts the value of `self` to an `u128`. Read more

#### `fn to_f32(&self) -> Option<f32>`[src]

Converts the value of `self` to an `f32`.

### `impl FromPrimitive for Decimal`[src]

#### `fn from_isize(n: isize) -> Option<Self>`[src]

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

#### `fn from_i8(n: i8) -> Option<Self>`[src]

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

#### `fn from_i16(n: i16) -> Option<Self>`[src]

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

#### `fn from_i128(n: i128) -> Option<Self>`[src]

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

#### `fn from_usize(n: usize) -> Option<Self>`[src]

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

#### `fn from_u8(n: u8) -> Option<Self>`[src]

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

#### `fn from_u16(n: u16) -> Option<Self>`[src]

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

#### `fn from_u128(n: u128) -> Option<Self>`[src]

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

### `impl Zero for Decimal`[src]

#### `fn set_zero(&mut self)`[src]

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

### `impl One for Decimal`[src]

#### `fn set_one(&mut self)`[src]

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

#### `fn is_one(&self) -> bool where    Self: PartialEq<Self>, `[src]

Returns `true` if `self` is equal to the multiplicative identity. Read more

## Blanket Implementations

### `impl<T> ToOwned for T where    T: Clone, `[src]

#### `type Owned = T`

The resulting type after obtaining ownership.

### `impl<T, U> TryFrom<U> for T where    U: Into<T>, `[src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

### `impl<T, U> TryInto<U> for T where    U: TryFrom<T>, `[src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.