fraction/decimal/ops/
mul_assign.rs

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

fraction/decimal/ops/
mul_assign.rs
