reweb3-num 0.2.4

Arbitrary precision, fixed-size signed and unsigned integer types for ethereum, this a fork of bnum crate.
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
122
123
124
125
126

macro_rules! digit_module {
    ($Digit: ident, $SignedDigit: ty, $DoubleDigit: ty) => {
        pub mod $Digit {
            mod types {
                pub type Digit = $Digit;

                pub type SignedDigit = $SignedDigit;

                pub type DoubleDigit = $DoubleDigit;
            }

            use crate::ExpType;

            pub use types::*;

            pub const BITS: ExpType = $Digit::BITS as ExpType;

            pub const BITS_U8: u8 = BITS as u8;

            pub const BITS_MINUS_1: ExpType = BITS - 1;

            pub const BYTES: ExpType = BITS / 8;

            // This calculates log2 of BYTES as BYTES is guaranteed to only have one '1' bit, since it must be a power of two.
            pub const BYTE_SHIFT: ExpType = BYTES.trailing_zeros() as ExpType;

            pub const BIT_SHIFT: ExpType = BITS.trailing_zeros() as ExpType;

            #[inline]
            pub const fn to_double_digit(low: Digit, high: Digit) -> DoubleDigit {
                ((high as DoubleDigit) << BITS) | low as DoubleDigit
            }

            // TODO: these will no longer be necessary once const_bigint_helper_methods is stabilised: https://github.com/rust-lang/rust/issues/85532

            #[inline]
            pub const fn carrying_add(a: Digit, b: Digit, carry: bool) -> (Digit, bool) {
                let (s1, o1) = a.overflowing_add(b);
                if carry {
                    let (s2, o2) = s1.overflowing_add(1);
                    (s2, o1 || o2)
                } else {
                    (s1, o1)
                }
            }

            #[inline]
            pub const fn borrowing_sub(a: Digit, b: Digit, borrow: bool) -> (Digit, bool) {
                let (s1, o1) = a.overflowing_sub(b);
                if borrow {
                    let (s2, o2) = s1.overflowing_sub(1);
                    (s2, o1 || o2)
                } else {
                    (s1, o1)
                }
            }

            #[inline]
            pub const fn carrying_add_signed(
                a: SignedDigit,
                b: SignedDigit,
                carry: bool,
            ) -> (SignedDigit, bool) {
                let (s1, o1) = a.overflowing_add(b);
                if carry {
                    let (s2, o2) = s1.overflowing_add(1);
                    (s2, o1 != o2)
                } else {
                    (s1, o1)
                }
            }

            #[inline]
            pub const fn borrowing_sub_signed(
                a: SignedDigit,
                b: SignedDigit,
                borrow: bool,
            ) -> (SignedDigit, bool) {
                let (s1, o1) = a.overflowing_sub(b);
                if borrow {
                    let (s2, o2) = s1.overflowing_sub(1);
                    (s2, o1 != o2)
                } else {
                    (s1, o1)
                }
            }

            #[inline]
            pub const fn widening_mul(a: Digit, b: Digit) -> (Digit, Digit) {
                let prod = a as DoubleDigit * b as DoubleDigit;
                (prod as Digit, (prod >> BITS) as Digit)
            }

            #[inline]
            pub const fn carrying_mul(
                a: Digit,
                b: Digit,
                carry: Digit,
                current: Digit,
            ) -> (Digit, Digit) {
                let prod = carry as DoubleDigit
                    + current as DoubleDigit
                    + (a as DoubleDigit) * (b as DoubleDigit);
                (prod as Digit, (prod >> BITS) as Digit)
            }

            #[inline]
            pub const fn div_rem_wide(low: Digit, high: Digit, rhs: Digit) -> (Digit, Digit) {
                debug_assert!(high < rhs);

                let a = to_double_digit(low, high);
                (
                    (a / rhs as DoubleDigit) as Digit,
                    (a % rhs as DoubleDigit) as Digit,
                )
            }

            pub const HEX_PADDING: usize = BITS as usize / 4;
        }
    };
}

digit_module!(u8, i8, u16);
digit_module!(u16, i16, u32);
digit_module!(u32, i32, u64);
digit_module!(u64, i64, u128);