rust_number 0.1.1

Rust port of number-precision for safer floating-point arithmetic
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

# rust_number

`rust_number` is a Rust port of [`number-precision`](https://github.com/nefe/number-precision) for safer decimal arithmetic with `f64`.

It helps avoid common floating-point surprises such as:

```text
0.1 + 0.2 != 0.3
1.0 - 0.9 != 0.1
3.0 * 0.3 != 0.9
```

## Features

- Corrects common precision issues for addition, subtraction, multiplication, division, and rounding
- Supports decimal strings and scientific notation
- Exposes helper utilities like `strip`, `digit_length`, and `float2fixed`
- Includes iterator-based helpers for multi-value operations

## Installation

Add this crate to your `Cargo.toml`:

```toml
[dependencies]
rust_number = "0.1.0"
```

## Quick Start

```rust
use rust_number::{divide, minus, plus, round, strip, times};

fn main() {
    assert_eq!(strip(0.09999999999999998_f64, 15), 0.1);
    assert_eq!(plus(0.1, 0.2), 0.3);
    assert_eq!(minus(1.0, 0.9), 0.1);
    assert_eq!(times(3, 0.3), 0.9);
    assert_eq!(divide(1.21, 1.1), 1.1);
    assert_eq!(round(0.105, 2), 0.11);
}
```

Run the example locally:

```bash
cargo run --example basic_usage
```

## API

- `strip(num, precision) -> f64`
- `digit_length(num) -> u32`
- `float2fixed(num) -> i128`
- `plus(a, b) -> f64`
- `minus(a, b) -> f64`
- `times(a, b) -> f64`
- `divide(a, b) -> f64`
- `round(num, decimal) -> f64`
- `plus_all(values) -> f64`
- `minus_all(values) -> f64`
- `times_all(values) -> f64`
- `divide_all(values) -> f64`
- `enable_boundary_checking(enabled)`

All numeric APIs accept:

- integer types
- `f32` / `f64`
- `&str`
- `String`

## Multi-Value Operations

```rust
use rust_number::{divide_all, plus_all, times_all};

fn main() {
    assert_eq!(plus_all([0.1, 0.2, 0.3]), 0.6);
    assert_eq!(times_all([0.1, 0.2, 10.0]), 0.2);
    assert_eq!(divide_all([1.2, 0.3, 2.0]), 2.0);
}
```

## Scientific Notation

```rust
use rust_number::{digit_length, divide, float2fixed, times};

fn main() {
    assert_eq!(digit_length(1.23e-5), 7);
    assert_eq!(float2fixed(1.23e-5), 123);
    assert_eq!(times("2.5e-3", "4e2"), 1.0);
    assert_eq!(divide("3e-4", "1.5e-2"), 0.02);
}
```

## Testing

```bash
cargo test
```

## License

MIT