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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use crate::decimal::{Decimal, DecimalError, ParseError, UnsignedDecimal};

type D<const N: usize> = Decimal<N>;
type UD<const N: usize> = UnsignedDecimal<N>;

impl<const N: usize> TryFrom<D<N>> for UD<N> {
    type Error = DecimalError;

    #[inline]
    fn try_from(d: D<N>) -> Result<Self, Self::Error> {
        if d.is_negative() {
            return Err(DecimalError::Invalid);
        }
        Ok(Self::new(d))
    }
}

macro_rules! from_uint_impl {
    ($($name:ident $uint:ident $(#$try: ident)?),*) => {
        impl<const N: usize> UD<N> {
            $(
                from_uint_impl!(@ $($try)? $name $uint);
            )*
        }

        $(
            from_uint_impl!(@@ $($try)? $name $uint);
        )*
    };
    (@ $name:ident $uint:ident) => {
        #[inline]
        #[doc = concat!("Converts [`", stringify!($uint), "`] to [Decimal].")]
        pub const fn $name(n: $uint) -> Self {
            Self::new(D::$name(n))
        }
    };
    (@ TRY $name:ident $uint:ident) => {
        #[inline]
        #[doc = concat!("Converts [`", stringify!($uint), "`] to [Decimal].")]
        pub const fn $name(n: $uint) -> Result<Self, ParseError> {
            match D::$name(n) {
                Ok(d) => Ok(Self::new(d)),
                Err(e) => Err(e),
            }
        }
    };
    (@@ $name:ident $uint:ident) => {
        impl<const N: usize> From<$uint> for UD<N> {
            #[inline]
            fn from(n: $uint) -> Self {
                Self::$name(n)
            }
        }
    };
    (@@ TRY $name:ident $uint:ident) => {
        impl<const N: usize> TryFrom<$uint> for UD<N> {
            type Error = ParseError;

            #[inline]
            fn try_from(n: $uint) -> Result<Self, Self::Error> {
                Self::$name(n)
            }
        }
    };
}

macro_rules! from_int_impl {
    ($($name:ident $int:ident $(#$try: ident)?),*) => {
        impl<const N: usize> UD<N> {
            $(
                #[inline]
                #[doc = concat!("Try converts [`", stringify!($int), "`] to [UnsignedDecimal].")]
                pub const fn $name(int: $int) -> Result<Self, ParseError> {
                    if int < 0 {
                        return Err(ParseError::Signed);
                    }

                    from_int_impl!(@ $($try)? $name int)
                }
            )*
        }

        $(
            impl<const N: usize> TryFrom<$int> for UD<N> {
                type Error = ParseError;

                #[inline]
                fn try_from(int: $int) -> Result<Self, Self::Error> {
                    Self::$name(int)
                }
            }
        )*
    };
    (@ $name:ident $int:ident) => {{
        Ok(Self::new(D::$name($int)))
    }};
    (@ TRY $name:ident $int:ident) => {{
        match D::$name($int) {
            Ok(d) => Ok(Self::new(d)),
            Err(e) => Err(e),
        }
    }};
}

macro_rules! try_from_f_impl {
    ($($name:ident $pname:ident $num:ty,)*) => {
        impl<const N: usize> UD<N> {
            $(
                #[inline]
                #[doc = concat!("Try converts [`", stringify!($num), "`] to [UnsignedDecimal].")]
                pub const fn $name(n: $num) -> Result<Self, ParseError> {
                    if n.is_sign_negative() {
                        return Err(ParseError::Signed);
                    }
                    Ok(Self::new(D::$pname(n)))
                }
            )*
        }

        $(
            impl<const N: usize> TryFrom<$num> for UD<N> {
                type Error = ParseError;

                #[inline]
                fn try_from(n: $num) -> Result<Self, Self::Error> {
                    Self::$name(n)
                }
            }
        )*
    };
}

from_uint_impl!(
    from_u8 u8,
    from_u16 u16,
    from_u32 u32,
    from_u64 u64,
    from_u128 u128 #TRY,
    from_usize usize
);

from_int_impl!(
    from_i8 i8,
    from_i16 i16,
    from_i32 i32,
    from_i64 i64,
    from_i128 i128 #TRY,
    from_isize isize
);

try_from_f_impl!(
    from_f32 from_f32 f32,
    from_f64 from_f64 f64,
);