[−][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 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 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 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 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 fn is_sign_negative(&self) -> bool`[src]

Returns true if the decimal is negative.

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

Returns true if the decimal is positive.

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

Returns the minimum possible number that Decimal can represent.

`pub 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");