categories = ["science","mathematics","data-structures"]

exclude = [ "tests/generated/*" ]

keywords = ["decimal","financial","fixed","precision","number"]

diesel1 = { default-features = false, optional = true, package = "diesel", version = "1.0" }

diesel2 = { default-features = false, optional = true, package = "diesel", version = "2.1" }

db-diesel-mysql = ["db-diesel1-mysql"]

db-diesel-postgres = ["db-diesel1-postgres"]

db-diesel1-mysql = ["diesel1/mysql", "std"]

db-diesel1-postgres = ["diesel1/postgres", "std"]

db-diesel2-mysql = ["diesel2/mysql", "std"]

db-diesel2-postgres = ["diesel2/postgres", "std"]

A Decimal number 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.

Decimal numbers can be created in a few distinct ways. The easiest and most efficient method of creating a Decimal is to use the procedural macro that can be enabled using the `macros` feature:

Alternatively you can also use one of the Decimal number convenience functions ([see the docs](https://docs.rs/rust_decimal/) for more details):

Enable `diesel` PostgreSQL support. By default, this enables version `1.4` of `diesel`. If you wish to use the `2.0`

version of `diesel` then you can do so by using the feature `db-diesel2-postgres`. Please note, if both features are

enabled then version 2 will supersede version 1.

Enable `diesel` MySQL support. By default, this enables version `1.4` of `diesel`. If you wish to use the `2.0`

version of `diesel` then you can do so by using the feature `db-diesel2-mysql`. Please note, if both features are

enabled then version 2 will supersede version 1.

As of `1.10` the algorithms used to perform basic operations have changed which has benefits of significant speed improvements.

[`MathematicalOps`](https://docs.rs/rust_decimal/latest/rust_decimal/trait.MathematicalOps.html) trait.

Please note that `ln` and `log10` will panic on invalid input with `checked_ln` and `checked_log10` the preferred functions

to curb against this. When the `maths` feature was first developed the library would instead return `0` on invalid input. To re-enable this

Note: When using `rand::Rng` trait to generate a decimal between a range of two other decimals, the scale of the randomly-generated

decimal will be the same as the scale of the input decimals (or, if the inputs have different scales, the higher of the two).

See also the `serde-with-*` features for greater flexibility.

See also the `serde-with-*` features for greater flexibility.

See also the `serde-with-*` features for greater flexibility.

Please note, this currently serializes numbers in a float like format by default, which can be an unexpected consequence. For greater

Enable this to access the module for serializing `Decimal` types to a float. This can be used in `struct` definitions like so:

Enable this to access the module for serializing `Decimal` types to a `String`. This can be used in `struct` definitions like so:

This feature isn't typically required for serialization however can be useful for deserialization purposes since it does not require

Enable this to access the module for deserializing `Decimal` types using the `serde_json/arbitrary_precision` feature. This can be used in `struct` definitions like so:

An unexpected consequence of this feature is that it will serialize as a float like number. To prevent this, you can

Enable `std` library support. This is enabled by default, however in the future will be opt in. For now, to support `no_std`

The current _minimum_ compiler version is [`1.60.0`](https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-1600-2022-04-07)

This library maintains support for rust compiler versions that are 4 minor versions away from the current stable rust compiler version.

For example, if the current stable compiler version is `1.50.0` then we will guarantee support up to and including `1.46.0`.

During the development of this library, there were various design decisions made to ensure that decimal calculations would

be quick, accurate and efficient. Some decisions, however, put limitations on what this library can do and ultimately what

it is suitable for. One such decision was the structure of the internal decimal representation.

This library uses a mantissa of 96 bits made up of three 32-bit unsigned integers with a fourth 32-bit unsigned integer to represent the scale/sign

(similar to the C and .NET Decimal implementations).

This structure allows us to make use of algorithmic optimizations to implement basic arithmetic; ultimately this gives us the ability

to squeeze out performance and make it one of the fastest implementations available. The downside of this approach however is that

While this constraint is not an issue for many applications (e.g. when dealing with money), some applications may require a higher number of significant digits to be represented. Fortunately,

If you have further questions about the suitability of this library for your project, then feel free to either start a

[discussion](https://github.com/paupino/rust-decimal/discussions) or open an [issue](https://github.com/paupino/rust-decimal/issues) and we'll