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

macro_rules! shift_impl {
    ($Ty: ident, $sign: ident, $Op: ident, $op: ident, $OpAssign: ident, $op_assign: ident) => {
        impl<const N: usize> $Op<ExpType> for $Ty<N> {
            type Output = Self;

            #[inline]
            fn $op(self, rhs: ExpType) -> Self::Output {
                Self::$op(self, rhs)
            }
        }

        impl<const N: usize> $OpAssign<ExpType> for $Ty<N> {
            #[inline]
            fn $op_assign(&mut self, rhs: ExpType) {
                self.0.$op_assign(rhs);
            }
        }

        shift_impl!(@ $Ty, $sign, $Op, $op, $OpAssign, $op_assign, [u8, u16, u64 #TRY, usize #TRY, u128 #TRY, i8 #TRY, i16 #TRY, i32 #TRY, i64 #TRY, isize #TRY, i128 #TRY]);
    };
    (@ $Ty: ident, $sign: ident, $Op: ident, $op: ident, $OpAssign: ident, $op_assign: ident, [$($ty: ident $(#$try: ident)?),*]) => {
        $(
            shift_impl!(@@ $($try)? $Ty, $sign, $Op, $op, $OpAssign, $op_assign, $ty);
        )*
    };
    (@@ $Ty: ident, $sign: ident, $Op: ident, $op: ident, $OpAssign: ident, $op_assign: ident, $ty: ident) => {
        impl<const N: usize> $Op<$ty> for $Ty<N> {
            type Output = Self;

            #[inline]
            fn $op(self, rhs: $ty) -> Self::Output {
                Self::$op(self, rhs as ExpType)
            }
        }

        impl<const N: usize> $OpAssign<$ty> for $Ty<N> {
            #[inline]
            fn $op_assign(&mut self, rhs: $ty) {
                self.0.$op_assign(rhs);
            }
        }
    };
    (@@ TRY $Ty: ident, $sign: ident, $Op: ident, $op: ident, $OpAssign: ident, $op_assign: ident, $ty: ident) => {
        impl<const N: usize> $Op<$ty> for $Ty<N> {
            type Output = Self;

            #[inline]
            fn $op(self, rhs: $ty) -> Self::Output {
                #[cfg(debug_assertions)]
                let rhs: ExpType = crate::utils::result_expect!(ExpType::try_from(rhs), crate::utils::err_msg!("attempt to shift with overflow"));

                #[cfg(not(debug_assertions))]
                let rhs = rhs as ExpType;

                Self::$op(self, rhs as ExpType)
            }
        }

        impl<const N: usize> $OpAssign<$ty> for $Ty<N> {
            #[inline]
            fn $op_assign(&mut self, rhs: $ty) {
                self.0.$op_assign(rhs);
            }
        }
    };
}

pub(crate) use shift_impl;