#decimal #financial #fixed #precision

rust_decimal

A Decimal Implementation written in pure Rust suitable for financial calculations

65 releases (30 stable)

1.14.2 Jun 7, 2021
1.12.3 Apr 29, 2021
1.10.3 Feb 15, 2021
1.9.0 Dec 28, 2020
0.1.0 Nov 16, 2016

#1 in Science

Download history 22231/week @ 2021-02-24 23372/week @ 2021-03-03 23723/week @ 2021-03-10 23265/week @ 2021-03-17 23884/week @ 2021-03-24 23091/week @ 2021-03-31 28369/week @ 2021-04-07 25035/week @ 2021-04-14 27158/week @ 2021-04-21 29113/week @ 2021-04-28 28792/week @ 2021-05-05 29125/week @ 2021-05-12 31385/week @ 2021-05-19 29929/week @ 2021-05-26 28881/week @ 2021-06-02 26227/week @ 2021-06-09

115,044 downloads per month
Used in 198 crates (86 directly)

MIT license

270KB
5.5K SLoC

Decimal   Build Status Latest Version Docs Badge

A Decimal implementation written in pure Rust suitable for financial calculations that require significant integral and fractional digits with no round-off errors.

The binary representation consists of a 96 bit integer number, a scaling factor used to specify the decimal fraction and a 1 bit sign. Because of this representation, trailing zeros are preserved and may be exposed when in string form. These can be truncated using the normalize or round_dp functions.

Getting started

To get started, add rust_decimal and optionally rust_decimal_macros to your Cargo.toml:

[dependencies]
rust_decimal = "1.14"
rust_decimal_macros = "1.14"

Usage

Decimal numbers can be created in a few distinct ways. The easiest and most optimal method of creating a Decimal is to use the procedural macro within the rust_decimal_macros crate:

// Procedural macros need importing directly
use rust_decimal_macros::dec;

let number = dec!(-1.23);
assert_eq!("-1.23", number.to_string());

Alternatively you can also use one of the Decimal number convenience functions:

// Using the prelude can help importing trait based functions (e.g. core::str::FromStr).
use rust_decimal::prelude::*;

// Using an integer followed by the decimal points
let scaled = Decimal::new(202, 2);
assert_eq!("2.02", scaled.to_string());

// From a string representation
let from_string = Decimal::from_str("2.02").unwrap();
assert_eq!("2.02", from_string.to_string());

// From a string representation in a different base
let from_string_base16 = Decimal::from_str_radix("ffff", 16).unwrap();
assert_eq!("65535", from_string_base16.to_string());

// Using the `Into` trait
let my_int: Decimal = 3i32.into();
assert_eq!("3", my_int.to_string());

// Using the raw decimal representation
let pi = Decimal::from_parts(1102470952, 185874565, 1703060790, false, 28);
assert_eq!("3.1415926535897932384626433832", pi.to_string());

Once you have instantiated your Decimal number you can perform calculations with it just like any other number:

use rust_decimal::prelude::*;

let amount = Decimal::from_str("25.12").unwrap();
let tax = Decimal::from_str("0.085").unwrap();
let total = amount + (amount * tax).round_dp(2);
assert_eq!(total.to_string(), "27.26");

Features

c-repr

Forces Decimal to use [repr(C)]. The corresponding target layout is 128 bit aligned.

db-postgres

This feature enables a PostgreSQL communication module. It allows for reading and writing the Decimal type by transparently serializing/deserializing into the NUMERIC data type within PostgreSQL.

db-tokio-postgres

Enables the tokio postgres module allowing for async communication with PostgreSQL.

db-diesel-postgres

Enable diesel PostgreSQL support.

legacy-ops

As of 1.10 the algorithms used to perform basic operations have changed which has benefits of significant speed improvements. To maintain backwards compatibility this can be opted out of by enabling the legacy-ops feature.

maths

The maths feature enables additional complex mathematical functions such as pow, ln, enf, exp etc. Documentation detailing the additional functions can be found on the MathematicalOps trait.

rust-fuzz

Enable rust-fuzz support by implementing the Arbitrary trait.

serde-float

Enable this so that JSON serialization of Decimal types are sent as a float instead of a string (default).

e.g. with this turned on, JSON serialization would output:

{
  "value": 1.234
}

serde-str

This is typically useful for bincode or csv like implementations.

Since bincode does not specify type information, we need to ensure that a type hint is provided in order to correctly be able to deserialize. Enabling this feature on its own will force deserialization to use deserialize_str instead of deserialize_any.

If, for some reason, you also have serde-float enabled then this will use deserialize_f64 as a type hint. Because converting to f64 loses precision, it's highly recommended that you do NOT enable this feature when working with bincode. That being said, this will only use 8 bytes so is slightly more efficient in terms of storage size.

serde-arbitrary-precision

This is used primarily with serde_json and consequently adds it as a "weak dependency". This supports the arbitrary_precision feature inside serde_json when parsing decimals.

This is recommended when parsing "float" looking data as it will prevent data loss.

std

Enable std library support. This is enabled by default, however in the future will be opt in. For now, to support no_std libraries, this crate can be compiled with --no-default-features.

Dependencies

~0.3–2.3MB
~47K SLoC