fraction/decimal/ops/
sub_assign.rs

1use std::cmp;
2use std::ops::SubAssign;
3
4use crate::{decimal::GenericDecimal, generic::GenericInteger};
5
6impl<O, T, P> SubAssign<O> for GenericDecimal<T, P>
7where
8    T: Clone + GenericInteger,
9    P: Copy + GenericInteger + Into<usize>,
10    O: Into<Self>,
11{
12    fn sub_assign(&mut self, other: O) {
13        let other: Self = other.into();
14
15        match *self {
16            GenericDecimal(ref mut sf, ref mut sp) => match other {
17                GenericDecimal(of, op) => {
18                    SubAssign::sub_assign(sf, of);
19                    *sp = cmp::max(*sp, op);
20                }
21            },
22        };
23    }
24}
25
26impl<'a, T, P> SubAssign<&'a Self> for GenericDecimal<T, P>
27where
28    T: Clone + GenericInteger, // + $trait + $trait<&'a T>,
29    P: Copy + GenericInteger + Into<usize>,
30{
31    fn sub_assign(&mut self, other: &'a Self) {
32        match *self {
33            GenericDecimal(ref mut sf, ref mut sp) => match other {
34                GenericDecimal(of, op) => {
35                    SubAssign::sub_assign(sf, of);
36                    *sp = cmp::max(*sp, *op);
37                }
38            },
39        };
40    }
41}
42
43#[cfg(test)]
44mod tests {
45    use crate::{GenericDecimal, One, Zero};
46
47    type F = GenericDecimal<u8, u8>;
48
49    #[test]
50    fn owned() {
51        {
52            let mut v = F::nan();
53            v -= F::nan();
54            assert_eq!(v, F::nan());
55        }
56
57        {
58            let mut v = F::infinity();
59            v -= F::nan();
60            assert_eq!(v, F::nan());
61        }
62
63        {
64            let mut v = F::infinity();
65            v -= F::infinity();
66            assert_eq!(v, F::nan());
67        }
68
69        {
70            let mut v = F::infinity();
71            v -= F::neg_infinity();
72            assert_eq!(v, F::infinity());
73        }
74
75        {
76            let mut v = F::infinity();
77            v -= F::one();
78            assert_eq!(v, F::infinity());
79        }
80
81        {
82            let mut v = F::one();
83            v -= F::nan();
84            assert_eq!(v, F::nan());
85        }
86
87        {
88            let mut v = F::one();
89            v -= F::infinity();
90            assert_eq!(v, F::neg_infinity());
91        }
92
93        {
94            let mut v = F::one();
95            v -= F::neg_infinity();
96            assert_eq!(v, F::infinity());
97        }
98
99        {
100            let mut v = F::one();
101            v -= -F::one();
102            assert_eq!(v, F::from(2));
103        }
104
105        {
106            let mut v = -F::one();
107            v -= F::from(2);
108            assert_eq!(v, -F::from(3));
109        }
110
111        {
112            let mut v = -F::one();
113            v -= -F::one();
114            assert_eq!(v, F::zero());
115        }
116
117        {
118            let mut v = -F::one();
119            v -= -F::from(2);
120            assert_eq!(v, F::one());
121        }
122    }
123
124    #[test]
125    fn refs() {
126        {
127            let mut v = F::nan();
128            v -= &F::nan();
129            assert_eq!(v, F::nan());
130        }
131
132        {
133            let mut v = F::infinity();
134            v -= &F::nan();
135            assert_eq!(v, F::nan());
136        }
137
138        {
139            let mut v = F::infinity();
140            v -= &F::infinity();
141            assert_eq!(v, F::nan());
142        }
143
144        {
145            let mut v = F::infinity();
146            v -= &F::neg_infinity();
147            assert_eq!(v, F::infinity());
148        }
149
150        {
151            let mut v = F::infinity();
152            v -= &F::one();
153            assert_eq!(v, F::infinity());
154        }
155
156        {
157            let mut v = F::one();
158            v -= &F::nan();
159            assert_eq!(v, F::nan());
160        }
161
162        {
163            let mut v = F::one();
164            v -= &F::infinity();
165            assert_eq!(v, F::neg_infinity());
166        }
167
168        {
169            let mut v = F::one();
170            v -= &F::neg_infinity();
171            assert_eq!(v, F::infinity());
172        }
173
174        {
175            let mut v = F::one();
176            v -= &(-F::one());
177            assert_eq!(v, F::from(2));
178        }
179
180        {
181            let mut v = -F::one();
182            v -= &F::from(2);
183            assert_eq!(v, -F::from(3));
184        }
185
186        {
187            let mut v = -F::one();
188            v -= &(-F::one());
189            assert_eq!(v, F::zero());
190        }
191
192        {
193            let mut v = -F::one();
194            v -= &(-F::from(2));
195            assert_eq!(v, F::one());
196        }
197    }
198
199    #[test]
200    fn cast() {
201        {
202            let mut v = F::one();
203            v -= 1;
204            assert_eq!(v, F::zero());
205        }
206
207        {
208            let mut v = F::one();
209            v -= 1;
210            assert_eq!(v, F::zero());
211        }
212    }
213}
fraction/decimal/ops/sub_assign.rs

fraction/decimal/ops/
sub_assign.rs
