[−][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 / 10^e, where m is an integer such that -2⁹⁶ < m < 2⁹⁶, 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 \
}");