rust-fixed-point-decimal 0.1.2

Decimal fixed-point arithmetic.
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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205

// ---------------------------------------------------------------------------
// Copyright:   (c) 2021 ff. Michael Amrhein (michael@adrhinum.de)
// License:     This program is part of a larger application. For license
//              details please read the file LICENSE.TXT provided together
//              with the application.
// ---------------------------------------------------------------------------
// $Source: tests/test_cmp.rs $
// $Revision: 2021-09-07T04:21:39+02:00 $

#![allow(incomplete_features)]
#![feature(generic_const_exprs)]

#[cfg(test)]
mod tests {
    use std::cmp::Ordering;

    use rust_fixed_point_decimal::{Dec, Decimal};

    #[test]
    fn test_ordering() {
        let test_data = [
            Decimal::<1>::MIN,
            Dec!(-3481900.3),
            Dec!(-0.4),
            Decimal::<1>::ZERO,
            Dec!(0.2),
            Decimal::<1>::ONE,
            Dec!(17.0),
            Decimal::<1>::MAX,
        ];
        for (i, x) in test_data.iter().enumerate() {
            for (j, y) in test_data.iter().enumerate() {
                assert_eq!(x.cmp(&y), i.cmp(&j));
            }
        }
    }

    macro_rules! gen_test_cmp {
        (
            $e1:expr,
            $e2:expr,
            $e3:expr,
            $e4:expr,
            $e5:expr,
            $e6:expr,
            $e7:expr,
            $e8:expr,
            $e9:expr,
            $e10:expr,
        ) => {
            #[test]
            fn test_cmp_1() {
                assert_eq!($e1.partial_cmp($e1).unwrap(), Ordering::Equal);
                assert_eq!($e1.partial_cmp($e2).unwrap(), Ordering::Less);
                assert_eq!($e1.partial_cmp($e3).unwrap(), Ordering::Less);
                assert_eq!($e1.partial_cmp($e4).unwrap(), Ordering::Less);
                assert_eq!($e1.partial_cmp($e5).unwrap(), Ordering::Less);
                assert_eq!($e1.partial_cmp($e6).unwrap(), Ordering::Less);
                assert_eq!($e1.partial_cmp($e7).unwrap(), Ordering::Less);
                assert_eq!($e1.partial_cmp($e8).unwrap(), Ordering::Less);
                assert_eq!($e1.partial_cmp($e9).unwrap(), Ordering::Less);
                assert_eq!($e1.partial_cmp($e10).unwrap(), Ordering::Less);
            }

            #[test]
            fn test_cmp_2() {
                assert_eq!($e2.partial_cmp($e1).unwrap(), Ordering::Greater);
                assert_eq!($e2.partial_cmp($e2).unwrap(), Ordering::Equal);
                assert_eq!($e2.partial_cmp($e3).unwrap(), Ordering::Less);
                assert_eq!($e2.partial_cmp($e4).unwrap(), Ordering::Less);
                assert_eq!($e2.partial_cmp($e5).unwrap(), Ordering::Less);
                assert_eq!($e2.partial_cmp($e6).unwrap(), Ordering::Less);
                assert_eq!($e2.partial_cmp($e7).unwrap(), Ordering::Less);
                assert_eq!($e2.partial_cmp($e8).unwrap(), Ordering::Less);
                assert_eq!($e2.partial_cmp($e9).unwrap(), Ordering::Less);
                assert_eq!($e2.partial_cmp($e10).unwrap(), Ordering::Less);
            }

            #[test]
            fn test_cmp_3() {
                assert_eq!($e3.partial_cmp($e1).unwrap(), Ordering::Greater);
                assert_eq!($e3.partial_cmp($e2).unwrap(), Ordering::Greater);
                assert_eq!($e3.partial_cmp($e3).unwrap(), Ordering::Equal);
                assert_eq!($e3.partial_cmp($e4).unwrap(), Ordering::Less);
                assert_eq!($e3.partial_cmp($e5).unwrap(), Ordering::Less);
                assert_eq!($e3.partial_cmp($e6).unwrap(), Ordering::Less);
                assert_eq!($e3.partial_cmp($e7).unwrap(), Ordering::Less);
                assert_eq!($e3.partial_cmp($e8).unwrap(), Ordering::Less);
                assert_eq!($e3.partial_cmp($e9).unwrap(), Ordering::Less);
                assert_eq!($e3.partial_cmp($e10).unwrap(), Ordering::Less);
            }

            #[test]
            fn test_cmp_4() {
                assert_eq!($e4.partial_cmp($e1).unwrap(), Ordering::Greater);
                assert_eq!($e4.partial_cmp($e2).unwrap(), Ordering::Greater);
                assert_eq!($e4.partial_cmp($e3).unwrap(), Ordering::Greater);
                assert_eq!($e4.partial_cmp($e4).unwrap(), Ordering::Equal);
                assert_eq!($e4.partial_cmp($e5).unwrap(), Ordering::Less);
                assert_eq!($e4.partial_cmp($e6).unwrap(), Ordering::Less);
                assert_eq!($e4.partial_cmp($e7).unwrap(), Ordering::Less);
                assert_eq!($e4.partial_cmp($e8).unwrap(), Ordering::Less);
                assert_eq!($e4.partial_cmp($e9).unwrap(), Ordering::Less);
                assert_eq!($e4.partial_cmp($e10).unwrap(), Ordering::Less);
            }

            #[test]
            fn test_cmp_5() {
                assert_eq!($e5.partial_cmp($e1).unwrap(), Ordering::Greater);
                assert_eq!($e5.partial_cmp($e2).unwrap(), Ordering::Greater);
                assert_eq!($e5.partial_cmp($e3).unwrap(), Ordering::Greater);
                assert_eq!($e5.partial_cmp($e4).unwrap(), Ordering::Greater);
                assert_eq!($e5.partial_cmp($e5).unwrap(), Ordering::Equal);
                assert_eq!($e5.partial_cmp($e6).unwrap(), Ordering::Less);
                assert_eq!($e5.partial_cmp($e7).unwrap(), Ordering::Less);
                assert_eq!($e5.partial_cmp($e8).unwrap(), Ordering::Less);
                assert_eq!($e5.partial_cmp($e9).unwrap(), Ordering::Less);
                assert_eq!($e5.partial_cmp($e10).unwrap(), Ordering::Less);
            }

            #[test]
            fn test_cmp_6() {
                assert_eq!($e6.partial_cmp($e1).unwrap(), Ordering::Greater);
                assert_eq!($e6.partial_cmp($e2).unwrap(), Ordering::Greater);
                assert_eq!($e6.partial_cmp($e3).unwrap(), Ordering::Greater);
                assert_eq!($e6.partial_cmp($e4).unwrap(), Ordering::Greater);
                assert_eq!($e6.partial_cmp($e5).unwrap(), Ordering::Greater);
                assert_eq!($e6.partial_cmp($e6).unwrap(), Ordering::Equal);
                assert_eq!($e6.partial_cmp($e7).unwrap(), Ordering::Less);
                assert_eq!($e6.partial_cmp($e8).unwrap(), Ordering::Less);
                assert_eq!($e6.partial_cmp($e9).unwrap(), Ordering::Less);
                assert_eq!($e6.partial_cmp($e10).unwrap(), Ordering::Less);
            }

            #[test]
            fn test_cmp_7() {
                assert_eq!($e7.partial_cmp($e1).unwrap(), Ordering::Greater);
                assert_eq!($e7.partial_cmp($e2).unwrap(), Ordering::Greater);
                assert_eq!($e7.partial_cmp($e3).unwrap(), Ordering::Greater);
                assert_eq!($e7.partial_cmp($e4).unwrap(), Ordering::Greater);
                assert_eq!($e7.partial_cmp($e5).unwrap(), Ordering::Greater);
                assert_eq!($e7.partial_cmp($e6).unwrap(), Ordering::Greater);
                assert_eq!($e7.partial_cmp($e7).unwrap(), Ordering::Equal);
                assert_eq!($e7.partial_cmp($e8).unwrap(), Ordering::Less);
                assert_eq!($e7.partial_cmp($e9).unwrap(), Ordering::Less);
                assert_eq!($e7.partial_cmp($e10).unwrap(), Ordering::Less);
            }

            #[test]
            fn test_cmp_8() {
                assert_eq!($e8.partial_cmp($e1).unwrap(), Ordering::Greater);
                assert_eq!($e8.partial_cmp($e2).unwrap(), Ordering::Greater);
                assert_eq!($e8.partial_cmp($e3).unwrap(), Ordering::Greater);
                assert_eq!($e8.partial_cmp($e4).unwrap(), Ordering::Greater);
                assert_eq!($e8.partial_cmp($e5).unwrap(), Ordering::Greater);
                assert_eq!($e8.partial_cmp($e6).unwrap(), Ordering::Greater);
                assert_eq!($e8.partial_cmp($e7).unwrap(), Ordering::Greater);
                assert_eq!($e8.partial_cmp($e8).unwrap(), Ordering::Equal);
                assert_eq!($e8.partial_cmp($e9).unwrap(), Ordering::Less);
                assert_eq!($e8.partial_cmp($e10).unwrap(), Ordering::Less);
            }

            #[test]
            fn test_cmp_9() {
                assert_eq!($e9.partial_cmp($e1).unwrap(), Ordering::Greater);
                assert_eq!($e9.partial_cmp($e2).unwrap(), Ordering::Greater);
                assert_eq!($e9.partial_cmp($e3).unwrap(), Ordering::Greater);
                assert_eq!($e9.partial_cmp($e4).unwrap(), Ordering::Greater);
                assert_eq!($e9.partial_cmp($e5).unwrap(), Ordering::Greater);
                assert_eq!($e9.partial_cmp($e6).unwrap(), Ordering::Greater);
                assert_eq!($e9.partial_cmp($e7).unwrap(), Ordering::Greater);
                assert_eq!($e9.partial_cmp($e8).unwrap(), Ordering::Greater);
                assert_eq!($e9.partial_cmp($e9).unwrap(), Ordering::Equal);
                assert_eq!($e9.partial_cmp($e10).unwrap(), Ordering::Less);
            }

            #[test]
            fn test_cmp_10() {
                assert_eq!($e10.partial_cmp($e1).unwrap(), Ordering::Greater);
                assert_eq!($e10.partial_cmp($e2).unwrap(), Ordering::Greater);
                assert_eq!($e10.partial_cmp($e3).unwrap(), Ordering::Greater);
                assert_eq!($e10.partial_cmp($e4).unwrap(), Ordering::Greater);
                assert_eq!($e10.partial_cmp($e5).unwrap(), Ordering::Greater);
                assert_eq!($e10.partial_cmp($e6).unwrap(), Ordering::Greater);
                assert_eq!($e10.partial_cmp($e7).unwrap(), Ordering::Greater);
                assert_eq!($e10.partial_cmp($e8).unwrap(), Ordering::Greater);
                assert_eq!($e10.partial_cmp($e9).unwrap(), Ordering::Greater);
                assert_eq!($e10.partial_cmp($e10).unwrap(), Ordering::Equal);
            }
        };
    }

    gen_test_cmp!(
        &Decimal::<1>::MIN,
        &Decimal::<3>::MIN,
        &Dec!(-34819.003),
        &Dec!(-0.0004),
        &Decimal::<1>::ZERO,
        &Dec!(0.02),
        &Decimal::<5>::ONE,
        &Dec!(17.000000007),
        &Decimal::<1>::MAX,
        &Decimal::<0>::MAX,
    );
}