pgnumeric 0.1.1

Arbitrary precision numeric implementation written in Rust, compatible with PostgreSQL's numeric.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

# pgnumeric

[![Apache-2.0 licensed](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
[![Minimum rustc version](https://img.shields.io/badge/rustc-1.43+-lightgray.svg)](README.md#rust-version-requirements)
[![Crate](https://img.shields.io/crates/v/pgnumeric.svg)](https://crates.io/crates/pgnumeric)
[![API](https://docs.rs/pgnumeric/badge.svg)](https://docs.rs/pgnumeric)

Arbitrary precision numeric implementation written in Rust, compatible with PostgreSQL's numeric.

See also: [PostgreSQL Arbitrary Precision Numbers](https://www.postgresql.org/docs/current/datatype-numeric.html#DATATYPE-NUMERIC-DECIMAL)

This crate provides two types, [`NumericBuf`] and [`Numeric`].

## Usage

To build a numeric, use `NumericBuf`:

```Rust
use pgnumeric::NumericBuf;

let n1: NumericBuf = "123".parse().unwrap();
let n2: NumericBuf = "456".parse().unwrap();
let result = n1 + n2;
assert_eq!(result.to_string(), "579");
```

To build a numeric from Rust primitive types:

```Rust
use pgnumeric::NumericBuf;

let n1: NumericBuf = From::from(123_i32);
let n2: NumericBuf = From::from(456_i32);
let result = n1 + n2;
assert_eq!(result, Into::<NumericBuf>::into(579_i32));
```

Numeric supports high precision arithmetic operations.

```Rust
use pgnumeric::NumericBuf;

let n1: NumericBuf = "123456789.987654321".parse().unwrap();
let n2: NumericBuf = "987654321.123456789".parse().unwrap();
let result = n1 * n2;
assert_eq!(result.to_string(), "121932632103337905.662094193112635269");

let n3 = "170141183460469231731687303715884105727".parse::<NumericBuf>().unwrap();
assert_eq!(n3.sqrt().to_string(), "13043817825332782212")
```

Numeric can be serialized to bytes slice and deserialized from bytes slice.

```Rust
use pgnumeric::{NumericBuf, Numeric};

let n1 = "123456789.987654321".parse::<NumericBuf>().unwrap();
let bytes = n1.as_bytes();
let n2 = unsafe { Numeric::from_bytes_unchecked(bytes) };
assert_eq!(n1, n2);
```

## Rust version requirements

`pgnumeric` works on rust `1.43`.

## License

This project is licensed under the Apache-2.0 license ([LICENSE](LICENSE) or http://www.apache.org/licenses/LICENSE-2.0).

## Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in `pgnumeric` by you, shall be licensed as Apache-2.0, without any additional
terms or conditions.