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::{
    doc,
    int::{intrinsics, math},
    intrinsics::{Digits, ExpType},
    num::num_impl,
    Int, UInt,
};

num_impl!(Int, I);

impl<const N: usize> Int<N> {
    #[doc = doc::num::mul!(I 256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn mul(self, rhs: Self) -> Self {
        Self(self.0.mul(rhs.0))
    }

    #[doc = doc::num::div!(I 256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn div(self, rhs: Self) -> Self {
        Self(self.0.div(rhs.0))
    }

    #[doc = doc::num::neg!(I 256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn neg(self) -> Self {
        Self(self.0.neg())
    }

    #[doc = doc::num::from_bits!(256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn from_bits(bits: UInt<N>) -> Self {
        Self(bnum::BInt::from_bits(bits.0))
    }

    #[doc = doc::num::to_bits!(256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn to_bits(self) -> UInt<N> {
        UInt(self.0.to_bits())
    }

    #[doc = doc::num::cast_unsigned!(256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn cast_unsigned(self) -> UInt<N> {
        self.to_bits()
    }

    #[doc = doc::num::unsigned_abs!(256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn unsigned_abs(self) -> UInt<N> {
        UInt(self.0.unsigned_abs())
    }

    #[doc = doc::num::abs!(256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn abs(self) -> Self {
        Self(self.0.abs())
    }

    #[doc = doc::num::signum!(256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn signum(self) -> Self {
        Self(self.0.signum())
    }

    #[doc = doc::num::is_positive!(256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn is_positive(self) -> bool {
        self.0.is_positive()
    }

    #[doc = doc::num::is_negative!(256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn is_negative(self) -> bool {
        self.0.is_negative()
    }

    #[doc = doc::num::abs_diff!(I 256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn abs_diff(self, other: Self) -> UInt<N> {
        UInt(self.0.abs_diff(other.0))
    }

    #[doc = doc::num::div_rem!(I 256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn div_rem(self, rhs: Self) -> (Self, Self) {
        math::div_rem(self, rhs)
    }

    #[doc = doc::num::from_digits!(I 256)]
    #[must_use = doc::must_use_op!()]
    #[inline(always)]
    pub const fn from_digits(digits: Digits<N>) -> Self {
        Self(bnum::BInt::from_bits(bnum::BUint::from_digits(digits)))
    }

    #[inline(always)]
    pub(crate) const fn last_digit_index(&self) -> usize {
        let bits = self.to_bits();
        bits.last_digit_index()
    }

    #[allow(unsafe_code)]
    #[inline(always)]
    pub(crate) const unsafe fn _transmute<const M: usize>(self) -> Int<M> {
        intrinsics::transmute(self)
    }
}