nexus-decimal 1.2.2

Fixed-point decimal arithmetic with compile-time precision
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

//! Compile-time power-of-10 lookup table.
//!
//! Covers `10^0` through `10^38` (full `i128` range).

/// Powers of 10 from `10^0` to `10^38`.
const POW10: [u128; 39] = [
    1,
    10,
    100,
    1_000,
    10_000,
    100_000,
    1_000_000,
    10_000_000,
    100_000_000, // 10^8
    1_000_000_000,
    10_000_000_000,
    100_000_000_000,
    1_000_000_000_000, // 10^12
    10_000_000_000_000,
    100_000_000_000_000,
    1_000_000_000_000_000,
    10_000_000_000_000_000,
    100_000_000_000_000_000,
    1_000_000_000_000_000_000, // 10^18
    10_000_000_000_000_000_000,
    100_000_000_000_000_000_000,
    1_000_000_000_000_000_000_000,
    10_000_000_000_000_000_000_000,
    100_000_000_000_000_000_000_000,
    1_000_000_000_000_000_000_000_000,
    10_000_000_000_000_000_000_000_000,
    100_000_000_000_000_000_000_000_000,
    1_000_000_000_000_000_000_000_000_000,
    10_000_000_000_000_000_000_000_000_000,
    100_000_000_000_000_000_000_000_000_000,
    1_000_000_000_000_000_000_000_000_000_000,
    10_000_000_000_000_000_000_000_000_000_000,
    100_000_000_000_000_000_000_000_000_000_000,
    1_000_000_000_000_000_000_000_000_000_000_000,
    10_000_000_000_000_000_000_000_000_000_000_000,
    100_000_000_000_000_000_000_000_000_000_000_000,
    1_000_000_000_000_000_000_000_000_000_000_000_000,
    10_000_000_000_000_000_000_000_000_000_000_000_000,
    100_000_000_000_000_000_000_000_000_000_000_000_000, // 10^38
];

#[inline(always)]
pub(crate) const fn pow10_i32(exp: u8) -> i32 {
    debug_assert!(exp <= 9, "10^exp overflows i32");
    POW10[exp as usize] as i32
}

#[inline(always)]
pub(crate) const fn pow10_i64(exp: u8) -> i64 {
    debug_assert!(exp <= 18, "10^exp overflows i64");
    POW10[exp as usize] as i64
}

#[inline(always)]
pub(crate) const fn pow10_i128(exp: u8) -> i128 {
    debug_assert!(exp <= 38, "10^exp overflows i128");
    POW10[exp as usize] as i128
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn table_correctness() {
        let mut expected: u128 = 1;
        for (i, &entry) in POW10.iter().enumerate() {
            assert_eq!(entry, expected, "POW10[{i}] mismatch");
            if i < 38 {
                expected *= 10;
            }
        }
    }

    #[test]
    fn i32_boundaries() {
        assert_eq!(pow10_i32(0), 1);
        assert_eq!(pow10_i32(9), 1_000_000_000);
        // 10^9 = 1,000,000,000 fits in i32 (max 2,147,483,647)
    }

    #[test]
    fn i64_boundaries() {
        assert_eq!(pow10_i64(0), 1);
        assert_eq!(pow10_i64(18), 1_000_000_000_000_000_000);
    }

    #[test]
    fn i128_boundaries() {
        assert_eq!(pow10_i128(0), 1);
        assert_eq!(
            pow10_i128(38),
            100_000_000_000_000_000_000_000_000_000_000_000_000
        );
    }
}