primitive_fixed_point_decimal 0.3.0

Primitive fixed-point decimal types.
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

use crate::fpdec_inner::FpdecInner;
use int_div_cum_error::{
    Rounding,
    checked_divide_with_rounding,
    checked_divide_with_cum_error,
};

macro_rules! calc_mul_div_higher {
    (
        $a:expr, $b:expr, $c:expr,
        $rounding:expr, $cum_error:expr,
        $origin_type:ty, $higher_type:ty
    ) => {
        {
            match $cum_error {
                Some(cum_error) => {
                    let mut higher_cum_error = *cum_error as $higher_type;
                    let q = checked_divide_with_cum_error(
                        $a as $higher_type * $b as $higher_type,
                        $c as $higher_type,
                        $rounding,
                        &mut higher_cum_error)?;

                    *cum_error = higher_cum_error as $origin_type;
                    <$origin_type>::try_from(q).ok()
                }
                None => {
                    let q = checked_divide_with_rounding(
                        $a as $higher_type * $b as $higher_type,
                        $c as $higher_type,
                        $rounding)?;
                    <$origin_type>::try_from(q).ok()
                }
            }
        }
    }
}

impl FpdecInner for i8 {
    const MAX: Self = i8::MAX;
    const MIN: Self = i8::MIN;
    const MAX_POWERS: Self = 10_i8.pow(2);

    fn get_exp(i: usize) -> Option<Self> {
        const ALL_EXPS: [i8; 3] = [
            1, 10_i8.pow(1), 10_i8.pow(2)
        ];

        ALL_EXPS.get(i).copied()
    }

    fn calc_mul_div(self, b: Self, c: Self, rounding: Rounding, cum_error: Option<&mut Self>)
        -> Option<Self>
    {
        calc_mul_div_higher!(self, b, c, rounding, cum_error, i8, i16)
    }
}

impl FpdecInner for i16 {
    const MAX: Self = i16::MAX;
    const MIN: Self = i16::MIN;
    const MAX_POWERS: Self = 10_i16.pow(4);

    fn get_exp(i: usize) -> Option<Self> {
        const ALL_EXPS: [i16; 5] = [
            1,
            10_i16.pow(1), 10_i16.pow(2), 10_i16.pow(3), 10_i16.pow(4),
        ];

        ALL_EXPS.get(i).copied()
    }

    fn calc_mul_div(self, b: Self, c: Self, rounding: Rounding, cum_error: Option<&mut Self>)
        -> Option<Self>
    {
        calc_mul_div_higher!(self, b, c, rounding, cum_error, i16, i32)
    }
}

impl FpdecInner for i32 {
    const MAX: Self = i32::MAX;
    const MIN: Self = i32::MIN;
    const MAX_POWERS: Self = 10_i32.pow(9);

    fn get_exp(i: usize) -> Option<Self> {
        const ALL_EXPS: [i32; 10] = [
            1,
            10_i32.pow(1), 10_i32.pow(2), 10_i32.pow(3), 10_i32.pow(4),
            10_i32.pow(5), 10_i32.pow(6), 10_i32.pow(7), 10_i32.pow(8),
            10_i32.pow(9)
        ];

        ALL_EXPS.get(i).copied()
    }

    fn calc_mul_div(self, b: Self, c: Self, rounding: Rounding, cum_error: Option<&mut Self>)
        -> Option<Self>
    {
        calc_mul_div_higher!(self, b, c, rounding, cum_error, i32, i64)
    }
}

impl FpdecInner for i64 {
    const MAX: Self = i64::MAX;
    const MIN: Self = i64::MIN;
    const MAX_POWERS: Self = 10_i64.pow(18);

    fn get_exp(i: usize) -> Option<Self> {
        const ALL_EXPS: [i64; 19] = [
            1,
            10_i64.pow(1), 10_i64.pow(2), 10_i64.pow(3), 10_i64.pow(4),
            10_i64.pow(5), 10_i64.pow(6), 10_i64.pow(7), 10_i64.pow(8),
            10_i64.pow(9), 10_i64.pow(10), 10_i64.pow(11), 10_i64.pow(12),
            10_i64.pow(13), 10_i64.pow(14), 10_i64.pow(15), 10_i64.pow(16),
            10_i64.pow(17), 10_i64.pow(18),
        ];

        ALL_EXPS.get(i).copied()
    }

    fn calc_mul_div(self, b: Self, c: Self, rounding: Rounding, cum_error: Option<&mut Self>)
    -> Option<Self>
    {
        calc_mul_div_higher!(self, b, c, rounding, cum_error, i64, i128)
    }
}