fastnum 0.7.4

Fast decimal numbers library
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::{
    bint::{
        intrinsics::{ExpType, *},
        UInt,
    },
    utils::err_msg,
};

macro_rules! powers_impl {
    ($struct_: ident, $DIGIT_POWER: ident, $BASE: ident, $log: expr) => {
        pub(super) struct $struct_<const N: usize> {
            powers: [[UInt<N>; $DIGIT_POWER as usize + 1]; N],
            max_reduced_by_powers: [[UInt<N>; $DIGIT_POWER as usize + 1]; N],
        }

        impl<const N: usize> $struct_<N> {
            pub(super) const MAX_POWER: ExpType = $log;

            const PREV: UInt<N> = UInt::<N>::MAX.div(UInt::$BASE);

            pub(super) const fn new() -> Self {
                debug_assert!(N > 0);
                debug_assert!(Self::MAX_POWER < ($DIGIT_POWER + 1) * (N as ExpType));

                let mut powers = [[UInt::ZERO; $DIGIT_POWER as usize + 1]; N];
                let mut max_reduced_by_powers = [[UInt::ZERO; $DIGIT_POWER as usize + 1]; N];

                powers[0][0] = UInt::ONE;
                max_reduced_by_powers[0][0] = UInt::MAX;

                let mut v;
                let mut j = 0;
                let mut i = 1;
                v = UInt::ONE;

                while v.le(&Self::PREV) {
                    v = v.strict_mul(UInt::$BASE);

                    powers[j][i] = v;
                    max_reduced_by_powers[j][i] = UInt(UInt::MAX.0.div(v.0));

                    i += 1;

                    if i == $DIGIT_POWER as usize + 1 {
                        i = 0;
                        j += 1;
                    }
                }

                Self {
                    powers,
                    max_reduced_by_powers,
                }
            }

            #[inline(always)]
            pub(super) const fn power(&self, power: ExpType) -> UInt<N> {
                debug_assert!(power <= Self::MAX_POWER);

                let j = (power / ($DIGIT_POWER + 1)) as usize;

                if j >= N {
                    panic!(err_msg!("power is too large"));
                }

                let i = (power % ($DIGIT_POWER + 1)) as usize;
                self.powers[j][i]
            }

            #[inline(always)]
            pub(super) const fn checked_power(&self, power: ExpType) -> Option<UInt<N>> {
                if power > Self::MAX_POWER {
                    None
                } else {
                    Some(self.power(power))
                }
            }

            #[allow(dead_code)]
            #[inline(always)]
            pub(super) const fn max_reduced_by_power(&self, power: ExpType) -> UInt<N> {
                debug_assert!(power <= Self::MAX_POWER);

                let j = (power / ($DIGIT_POWER + 1)) as usize;

                if j >= N {
                    panic!(err_msg!("power is too large"));
                }

                let i = (power % ($DIGIT_POWER + 1)) as usize;
                self.max_reduced_by_powers[j][i]
            }

            #[allow(dead_code)]
            #[inline(always)]
            pub(super) const fn checked_max_reduced_by_power(
                &self,
                power: ExpType,
            ) -> Option<UInt<N>> {
                if power > Self::MAX_POWER {
                    None
                } else {
                    Some(self.max_reduced_by_power(power))
                }
            }
        }
    };
}

powers_impl!(
    PowersOf10,
    DIGIT_POWER_10,
    TEN,
    bnum::BUint::<N>::MAX.ilog10()
);
powers_impl!(
    PowersOf5,
    DIGIT_POWER_5,
    FIVE,
    bnum::BUint::<N>::MAX.ilog(bnum::BUint::FIVE)
);