1use super::GenericDecimal;
2use generic::GenericInteger;
3use num::ToPrimitive;
4use std::convert::TryFrom;
5
6macro_rules! generic_decimal_into_primitive {
7 ( $( $(#[$cfg:meta])* fn $method:ident -> $IntoT:ident ; )*) => {$(
8 $(#[$cfg])*
9 impl<T, P> TryFrom<GenericDecimal<T, P>> for $IntoT
10 where
11 T: Clone + ToPrimitive + GenericInteger,
12 P: Copy + Into<usize> + GenericInteger
13 {
14 type Error = ();
15
16 fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error> {
17 value.$method().ok_or(())
18 }
19 }
20 )*}
21}
22
23generic_decimal_into_primitive!(
24 fn to_u8 -> u8 ;
25 fn to_i8 -> i8 ;
26 fn to_u16 -> u16 ;
27 fn to_i16 -> i16 ;
28 fn to_u32 -> u32 ;
29 fn to_i32 -> i32 ;
30 fn to_u64 -> u64 ;
31 fn to_i64 -> i64 ;
32 fn to_u128 -> u128 ;
33 fn to_i128 -> i128 ;
34 fn to_usize -> usize ;
35 fn to_isize -> isize ;
36 fn to_f32 -> f32 ;
37 fn to_f64 -> f64 ;
38);
39
40#[cfg(feature = "with-bigint")]
41pub mod with_bigint {
42 use num::BigInt;
43
44 use crate::{generic::GenericInteger, BigUint, GenericDecimal};
45 use std::convert::TryFrom;
46
47 impl<T, P> TryFrom<GenericDecimal<T, P>> for BigUint
48 where
49 T: Clone + GenericInteger,
50 P: Copy + GenericInteger + Into<usize>,
51 {
52 type Error = ();
53
54 fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error> {
55 Self::try_from(value.0)
56 }
57 }
58
59 impl<T, P> TryFrom<GenericDecimal<T, P>> for BigInt
60 where
61 T: Clone + GenericInteger,
62 P: Copy + GenericInteger + Into<usize>,
63 {
64 type Error = ();
65
66 fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error> {
67 Self::try_from(value.0)
68 }
69 }
70}
71
72#[cfg(test)]
73mod test {
74 use crate::prelude::Decimal;
75 use num::{One, Zero};
76 use std::convert::TryInto;
77
78 #[test]
79 fn decimal_to_i() {
80 let n_inf = Decimal::neg_infinity();
81 let n_one = Decimal::one() * -1;
82 let n_half = n_one / 2;
83 let zero = Decimal::zero();
84 let p_one = Decimal::one();
85 let p_half = p_one / 2;
86 let p_inf = Decimal::infinity();
87 let nan = Decimal::nan();
88
89 assert_eq!(n_inf.try_into() as Result<i8, ()>, Err(()));
90 assert_eq!(n_inf.try_into() as Result<i16, ()>, Err(()));
91 assert_eq!(n_inf.try_into() as Result<i32, ()>, Err(()));
92 assert_eq!(n_inf.try_into() as Result<i64, ()>, Err(()));
93 assert_eq!(n_inf.try_into() as Result<i128, ()>, Err(()));
94 assert_eq!(n_inf.try_into() as Result<isize, ()>, Err(()));
95
96 assert_eq!(n_one.try_into(), Ok(-1i8));
97 assert_eq!(n_one.try_into(), Ok(-1i16));
98 assert_eq!(n_one.try_into(), Ok(-1i32));
99 assert_eq!(n_one.try_into(), Ok(-1i64));
100 assert_eq!(n_one.try_into(), Ok(-1i128));
101 assert_eq!(n_one.try_into(), Ok(-1isize));
102
103 assert_eq!(n_half.try_into() as Result<i8, ()>, Err(()));
104 assert_eq!(n_half.try_into() as Result<i16, ()>, Err(()));
105 assert_eq!(n_half.try_into() as Result<i32, ()>, Err(()));
106 assert_eq!(n_half.try_into() as Result<i64, ()>, Err(()));
107 assert_eq!(n_half.try_into() as Result<i128, ()>, Err(()));
108 assert_eq!(n_half.try_into() as Result<isize, ()>, Err(()));
109
110 assert_eq!(zero.try_into(), Ok(0i8));
111 assert_eq!(zero.try_into(), Ok(0i16));
112 assert_eq!(zero.try_into(), Ok(0i32));
113 assert_eq!(zero.try_into(), Ok(0i64));
114 assert_eq!(zero.try_into(), Ok(0i128));
115 assert_eq!(zero.try_into(), Ok(0isize));
116
117 assert_eq!(p_half.try_into() as Result<i8, ()>, Err(()));
118 assert_eq!(p_half.try_into() as Result<i16, ()>, Err(()));
119 assert_eq!(p_half.try_into() as Result<i32, ()>, Err(()));
120 assert_eq!(p_half.try_into() as Result<i64, ()>, Err(()));
121 assert_eq!(p_half.try_into() as Result<i128, ()>, Err(()));
122 assert_eq!(p_half.try_into() as Result<isize, ()>, Err(()));
123
124 assert_eq!(p_one.try_into(), Ok(1i8));
125 assert_eq!(p_one.try_into(), Ok(1i16));
126 assert_eq!(p_one.try_into(), Ok(1i32));
127 assert_eq!(p_one.try_into(), Ok(1i64));
128 assert_eq!(p_one.try_into(), Ok(1i128));
129 assert_eq!(p_one.try_into(), Ok(1isize));
130
131 assert_eq!(p_inf.try_into() as Result<i8, ()>, Err(()));
132 assert_eq!(p_inf.try_into() as Result<i16, ()>, Err(()));
133 assert_eq!(p_inf.try_into() as Result<i32, ()>, Err(()));
134 assert_eq!(p_inf.try_into() as Result<i64, ()>, Err(()));
135 assert_eq!(p_inf.try_into() as Result<i128, ()>, Err(()));
136 assert_eq!(p_inf.try_into() as Result<isize, ()>, Err(()));
137
138 assert_eq!(nan.try_into() as Result<i8, ()>, Err(()));
139 assert_eq!(nan.try_into() as Result<i16, ()>, Err(()));
140 assert_eq!(nan.try_into() as Result<i32, ()>, Err(()));
141 assert_eq!(nan.try_into() as Result<i64, ()>, Err(()));
142 assert_eq!(nan.try_into() as Result<i128, ()>, Err(()));
143 assert_eq!(nan.try_into() as Result<isize, ()>, Err(()));
144 }
145
146 #[test]
147 fn decimal_to_u() {
148 let n_inf = Decimal::neg_infinity();
149 let n_one = Decimal::one() * -1;
150 let n_half = n_one / 2;
151 let zero = Decimal::zero();
152 let p_one = Decimal::one();
153 let p_half = p_one / 2;
154 let p_inf = Decimal::infinity();
155 let nan = Decimal::nan();
156
157 assert_eq!(n_inf.try_into() as Result<u8, ()>, Err(()));
158 assert_eq!(n_inf.try_into() as Result<u16, ()>, Err(()));
159 assert_eq!(n_inf.try_into() as Result<u32, ()>, Err(()));
160 assert_eq!(n_inf.try_into() as Result<u64, ()>, Err(()));
161 assert_eq!(n_inf.try_into() as Result<u128, ()>, Err(()));
162 assert_eq!(n_inf.try_into() as Result<usize, ()>, Err(()));
163
164 assert_eq!(n_one.try_into() as Result<u8, ()>, Err(()));
165 assert_eq!(n_one.try_into() as Result<u16, ()>, Err(()));
166 assert_eq!(n_one.try_into() as Result<u32, ()>, Err(()));
167 assert_eq!(n_one.try_into() as Result<u64, ()>, Err(()));
168 assert_eq!(n_one.try_into() as Result<u128, ()>, Err(()));
169 assert_eq!(n_one.try_into() as Result<usize, ()>, Err(()));
170
171 assert_eq!(n_half.try_into() as Result<u8, ()>, Err(()));
172 assert_eq!(n_half.try_into() as Result<u16, ()>, Err(()));
173 assert_eq!(n_half.try_into() as Result<u32, ()>, Err(()));
174 assert_eq!(n_half.try_into() as Result<u64, ()>, Err(()));
175 assert_eq!(n_half.try_into() as Result<u128, ()>, Err(()));
176 assert_eq!(n_half.try_into() as Result<usize, ()>, Err(()));
177
178 assert_eq!(zero.try_into(), Ok(0u8));
179 assert_eq!(zero.try_into(), Ok(0u16));
180 assert_eq!(zero.try_into(), Ok(0u32));
181 assert_eq!(zero.try_into(), Ok(0u64));
182 assert_eq!(zero.try_into(), Ok(0u128));
183 assert_eq!(zero.try_into(), Ok(0usize));
184
185 assert_eq!(p_half.try_into() as Result<u8, ()>, Err(()));
186 assert_eq!(p_half.try_into() as Result<u16, ()>, Err(()));
187 assert_eq!(p_half.try_into() as Result<u32, ()>, Err(()));
188 assert_eq!(p_half.try_into() as Result<u64, ()>, Err(()));
189 assert_eq!(p_half.try_into() as Result<u128, ()>, Err(()));
190 assert_eq!(p_half.try_into() as Result<usize, ()>, Err(()));
191
192 assert_eq!(p_one.try_into(), Ok(1u8));
193 assert_eq!(p_one.try_into(), Ok(1u16));
194 assert_eq!(p_one.try_into(), Ok(1u32));
195 assert_eq!(p_one.try_into(), Ok(1u64));
196 assert_eq!(p_one.try_into(), Ok(1u128));
197 assert_eq!(p_one.try_into(), Ok(1usize));
198
199 assert_eq!(p_inf.try_into() as Result<u8, ()>, Err(()));
200 assert_eq!(p_inf.try_into() as Result<u16, ()>, Err(()));
201 assert_eq!(p_inf.try_into() as Result<u32, ()>, Err(()));
202 assert_eq!(p_inf.try_into() as Result<u64, ()>, Err(()));
203 assert_eq!(p_inf.try_into() as Result<u128, ()>, Err(()));
204 assert_eq!(p_inf.try_into() as Result<usize, ()>, Err(()));
205
206 assert_eq!(nan.try_into() as Result<u8, ()>, Err(()));
207 assert_eq!(nan.try_into() as Result<u16, ()>, Err(()));
208 assert_eq!(nan.try_into() as Result<u32, ()>, Err(()));
209 assert_eq!(nan.try_into() as Result<u64, ()>, Err(()));
210 assert_eq!(nan.try_into() as Result<u128, ()>, Err(()));
211 assert_eq!(nan.try_into() as Result<usize, ()>, Err(()));
212 }
213
214 #[test]
215 fn decimal_to_f32() {
216 let n_inf = Decimal::neg_infinity();
217 let n_one = Decimal::one() * -1;
218 let n_half = n_one / 2;
219 let zero = Decimal::zero();
220 let p_one = Decimal::one();
221 let p_half = p_one / 2;
222 let p_inf = Decimal::infinity();
223 let nan = Decimal::nan();
224
225 assert_eq!(n_inf.try_into(), Ok(f32::NEG_INFINITY));
226 assert_eq!(n_one.try_into(), Ok(-1f32));
227 assert_eq!(n_half.try_into(), Ok(-0.5f32));
228 assert_eq!(zero.try_into(), Ok(0f32));
229 assert_eq!(p_half.try_into(), Ok(0.5f32));
230 assert_eq!(p_one.try_into(), Ok(1f32));
231 assert_eq!(p_inf.try_into(), Ok(f32::INFINITY));
232 assert!((nan.try_into() as Result<f32, ()>).unwrap_or(0f32).is_nan());
233 }
234
235 #[test]
236 fn decimal_to_f64() {
237 let n_inf = Decimal::neg_infinity();
238 let n_one = Decimal::one() * -1;
239 let n_half = n_one / 2;
240 let zero = Decimal::zero();
241 let p_one = Decimal::one();
242 let p_half = p_one / 2;
243 let p_inf = Decimal::infinity();
244 let nan = Decimal::nan();
245
246 assert_eq!(n_inf.try_into(), Ok(f64::NEG_INFINITY));
247 assert_eq!(n_one.try_into(), Ok(-1f64));
248 assert_eq!(n_half.try_into(), Ok(-0.5f64));
249 assert_eq!(zero.try_into(), Ok(0f64));
250 assert_eq!(p_half.try_into(), Ok(0.5f64));
251 assert_eq!(p_one.try_into(), Ok(1f64));
252 assert_eq!(p_inf.try_into(), Ok(f64::INFINITY));
253 assert!((nan.try_into() as Result<f64, ()>).unwrap_or(0f64).is_nan());
254 }
255
256 #[cfg(feature = "with-bigint")]
257 #[test]
258 fn decimal_to_bigint() {
259 use crate::BigInt;
260
261 let n_inf = Decimal::neg_infinity();
262 let n_one = Decimal::one() * -1;
263 let n_half = n_one / 2;
264 let zero = Decimal::zero();
265 let p_one = Decimal::one();
266 let p_half = p_one / 2;
267 let p_inf = Decimal::infinity();
268 let nan = Decimal::nan();
269
270 assert_eq!(n_inf.try_into() as Result<BigInt, ()>, Err(()));
271 assert_eq!(n_one.try_into(), Ok(BigInt::one() * -1));
272 assert_eq!(n_half.try_into() as Result<BigInt, ()>, Err(()));
273 assert_eq!(zero.try_into(), Ok(BigInt::zero()));
274 assert_eq!(p_half.try_into() as Result<BigInt, ()>, Err(()));
275 assert_eq!(p_one.try_into(), Ok(BigInt::one()));
276 assert_eq!(p_inf.try_into() as Result<BigInt, ()>, Err(()));
277 assert_eq!(nan.try_into() as Result<BigInt, ()>, Err(()));
278 }
279
280 #[cfg(feature = "with-bigint")]
281 #[test]
282 fn decimal_to_biguint() {
283 use crate::BigUint;
284
285 let n_inf = Decimal::neg_infinity();
286 let n_one = Decimal::one() * -1;
287 let n_half = n_one / 2;
288 let zero = Decimal::zero();
289 let p_one = Decimal::one();
290 let p_half = p_one / 2;
291 let p_inf = Decimal::infinity();
292 let nan = Decimal::nan();
293
294 assert_eq!(n_inf.try_into() as Result<BigUint, ()>, Err(()));
295 assert_eq!(n_one.try_into() as Result<BigUint, ()>, Err(()));
296 assert_eq!(n_half.try_into() as Result<BigUint, ()>, Err(()));
297 assert_eq!(zero.try_into(), Ok(BigUint::zero()));
298 assert_eq!(p_half.try_into() as Result<BigUint, ()>, Err(()));
299 assert_eq!(p_one.try_into(), Ok(BigUint::one()));
300 assert_eq!(p_inf.try_into() as Result<BigUint, ()>, Err(()));
301 assert_eq!(nan.try_into() as Result<BigUint, ()>, Err(()));
302 }
303
304 #[cfg(feature = "with-bigint")]
305 #[test]
306 fn bigdecimal_to_i() {
307 use crate::BigDecimal;
308
309 let n_inf = BigDecimal::neg_infinity();
310 let n_one = BigDecimal::one() * -1;
311 let n_half = n_one.clone() / 2;
312 let zero = BigDecimal::zero();
313 let p_one = BigDecimal::one();
314 let p_half = p_one.clone() / 2;
315 let p_inf = BigDecimal::infinity();
316 let nan = BigDecimal::nan();
317
318 assert_eq!(n_inf.clone().try_into() as Result<i8, ()>, Err(()));
319 assert_eq!(n_inf.clone().try_into() as Result<i16, ()>, Err(()));
320 assert_eq!(n_inf.clone().try_into() as Result<i32, ()>, Err(()));
321 assert_eq!(n_inf.clone().try_into() as Result<i64, ()>, Err(()));
322 assert_eq!(n_inf.clone().try_into() as Result<i128, ()>, Err(()));
323 assert_eq!(n_inf.clone().try_into() as Result<isize, ()>, Err(()));
324
325 assert_eq!(n_one.clone().try_into(), Ok(-1i8));
326 assert_eq!(n_one.clone().try_into(), Ok(-1i16));
327 assert_eq!(n_one.clone().try_into(), Ok(-1i32));
328 assert_eq!(n_one.clone().try_into(), Ok(-1i64));
329 assert_eq!(n_one.clone().try_into(), Ok(-1i128));
330 assert_eq!(n_one.clone().try_into(), Ok(-1isize));
331
332 assert_eq!(n_half.clone().try_into() as Result<i8, ()>, Err(()));
333 assert_eq!(n_half.clone().try_into() as Result<i16, ()>, Err(()));
334 assert_eq!(n_half.clone().try_into() as Result<i32, ()>, Err(()));
335 assert_eq!(n_half.clone().try_into() as Result<i64, ()>, Err(()));
336 assert_eq!(n_half.clone().try_into() as Result<i128, ()>, Err(()));
337 assert_eq!(n_half.clone().try_into() as Result<isize, ()>, Err(()));
338
339 assert_eq!(zero.clone().try_into(), Ok(0i8));
340 assert_eq!(zero.clone().try_into(), Ok(0i16));
341 assert_eq!(zero.clone().try_into(), Ok(0i32));
342 assert_eq!(zero.clone().try_into(), Ok(0i64));
343 assert_eq!(zero.clone().try_into(), Ok(0i128));
344 assert_eq!(zero.clone().try_into(), Ok(0isize));
345
346 assert_eq!(p_half.clone().try_into() as Result<i8, ()>, Err(()));
347 assert_eq!(p_half.clone().try_into() as Result<i16, ()>, Err(()));
348 assert_eq!(p_half.clone().try_into() as Result<i32, ()>, Err(()));
349 assert_eq!(p_half.clone().try_into() as Result<i64, ()>, Err(()));
350 assert_eq!(p_half.clone().try_into() as Result<i128, ()>, Err(()));
351 assert_eq!(p_half.clone().try_into() as Result<isize, ()>, Err(()));
352
353 assert_eq!(p_one.clone().try_into(), Ok(1i8));
354 assert_eq!(p_one.clone().try_into(), Ok(1i16));
355 assert_eq!(p_one.clone().try_into(), Ok(1i32));
356 assert_eq!(p_one.clone().try_into(), Ok(1i64));
357 assert_eq!(p_one.clone().try_into(), Ok(1i128));
358 assert_eq!(p_one.clone().try_into(), Ok(1isize));
359
360 assert_eq!(p_inf.clone().try_into() as Result<i8, ()>, Err(()));
361 assert_eq!(p_inf.clone().try_into() as Result<i16, ()>, Err(()));
362 assert_eq!(p_inf.clone().try_into() as Result<i32, ()>, Err(()));
363 assert_eq!(p_inf.clone().try_into() as Result<i64, ()>, Err(()));
364 assert_eq!(p_inf.clone().try_into() as Result<i128, ()>, Err(()));
365 assert_eq!(p_inf.clone().try_into() as Result<isize, ()>, Err(()));
366
367 assert_eq!(nan.clone().try_into() as Result<i8, ()>, Err(()));
368 assert_eq!(nan.clone().try_into() as Result<i16, ()>, Err(()));
369 assert_eq!(nan.clone().try_into() as Result<i32, ()>, Err(()));
370 assert_eq!(nan.clone().try_into() as Result<i64, ()>, Err(()));
371 assert_eq!(nan.clone().try_into() as Result<i128, ()>, Err(()));
372 assert_eq!(nan.clone().try_into() as Result<isize, ()>, Err(()));
373 }
374
375 #[cfg(feature = "with-bigint")]
376 #[test]
377 fn bigintdecimal_to_i() {
378 use crate::GenericDecimal;
379 use num::BigInt;
380
381 type BigDecimal = GenericDecimal<BigInt, u8>;
382
383 let n_inf = BigDecimal::neg_infinity();
384 let n_one = BigDecimal::one() * -1;
385 let n_half = n_one.clone() / 2;
386 let zero = BigDecimal::zero();
387 let p_one = BigDecimal::one();
388 let p_half = p_one.clone() / 2;
389 let p_inf = BigDecimal::infinity();
390 let nan = BigDecimal::nan();
391
392 assert_eq!(n_inf.clone().try_into() as Result<i8, ()>, Err(()));
393 assert_eq!(n_inf.clone().try_into() as Result<i16, ()>, Err(()));
394 assert_eq!(n_inf.clone().try_into() as Result<i32, ()>, Err(()));
395 assert_eq!(n_inf.clone().try_into() as Result<i64, ()>, Err(()));
396 assert_eq!(n_inf.clone().try_into() as Result<i128, ()>, Err(()));
397 assert_eq!(n_inf.clone().try_into() as Result<isize, ()>, Err(()));
398
399 assert_eq!(n_one.clone().try_into(), Ok(-1i8));
400 assert_eq!(n_one.clone().try_into(), Ok(-1i16));
401 assert_eq!(n_one.clone().try_into(), Ok(-1i32));
402 assert_eq!(n_one.clone().try_into(), Ok(-1i64));
403 assert_eq!(n_one.clone().try_into(), Ok(-1i128));
404 assert_eq!(n_one.clone().try_into(), Ok(-1isize));
405
406 assert_eq!(n_half.clone().try_into() as Result<i8, ()>, Err(()));
407 assert_eq!(n_half.clone().try_into() as Result<i16, ()>, Err(()));
408 assert_eq!(n_half.clone().try_into() as Result<i32, ()>, Err(()));
409 assert_eq!(n_half.clone().try_into() as Result<i64, ()>, Err(()));
410 assert_eq!(n_half.clone().try_into() as Result<i128, ()>, Err(()));
411 assert_eq!(n_half.clone().try_into() as Result<isize, ()>, Err(()));
412
413 assert_eq!(zero.clone().try_into(), Ok(0i8));
414 assert_eq!(zero.clone().try_into(), Ok(0i16));
415 assert_eq!(zero.clone().try_into(), Ok(0i32));
416 assert_eq!(zero.clone().try_into(), Ok(0i64));
417 assert_eq!(zero.clone().try_into(), Ok(0i128));
418 assert_eq!(zero.clone().try_into(), Ok(0isize));
419
420 assert_eq!(p_half.clone().try_into() as Result<i8, ()>, Err(()));
421 assert_eq!(p_half.clone().try_into() as Result<i16, ()>, Err(()));
422 assert_eq!(p_half.clone().try_into() as Result<i32, ()>, Err(()));
423 assert_eq!(p_half.clone().try_into() as Result<i64, ()>, Err(()));
424 assert_eq!(p_half.clone().try_into() as Result<i128, ()>, Err(()));
425 assert_eq!(p_half.clone().try_into() as Result<isize, ()>, Err(()));
426
427 assert_eq!(p_one.clone().try_into(), Ok(1i8));
428 assert_eq!(p_one.clone().try_into(), Ok(1i16));
429 assert_eq!(p_one.clone().try_into(), Ok(1i32));
430 assert_eq!(p_one.clone().try_into(), Ok(1i64));
431 assert_eq!(p_one.clone().try_into(), Ok(1i128));
432 assert_eq!(p_one.clone().try_into(), Ok(1isize));
433
434 assert_eq!(p_inf.clone().try_into() as Result<i8, ()>, Err(()));
435 assert_eq!(p_inf.clone().try_into() as Result<i16, ()>, Err(()));
436 assert_eq!(p_inf.clone().try_into() as Result<i32, ()>, Err(()));
437 assert_eq!(p_inf.clone().try_into() as Result<i64, ()>, Err(()));
438 assert_eq!(p_inf.clone().try_into() as Result<i128, ()>, Err(()));
439 assert_eq!(p_inf.clone().try_into() as Result<isize, ()>, Err(()));
440
441 assert_eq!(nan.clone().try_into() as Result<i8, ()>, Err(()));
442 assert_eq!(nan.clone().try_into() as Result<i16, ()>, Err(()));
443 assert_eq!(nan.clone().try_into() as Result<i32, ()>, Err(()));
444 assert_eq!(nan.clone().try_into() as Result<i64, ()>, Err(()));
445 assert_eq!(nan.clone().try_into() as Result<i128, ()>, Err(()));
446 assert_eq!(nan.clone().try_into() as Result<isize, ()>, Err(()));
447 }
448
449 #[cfg(feature = "with-bigint")]
450 #[test]
451 fn bigdecimal_to_u() {
452 use crate::BigDecimal;
453
454 let n_inf = BigDecimal::neg_infinity();
455 let n_one = BigDecimal::one() * -1;
456 let n_half = n_one.clone() / 2;
457 let zero = BigDecimal::zero();
458 let p_one = BigDecimal::one();
459 let p_half = p_one.clone() / 2;
460 let p_inf = BigDecimal::infinity();
461 let nan = Decimal::nan();
462
463 assert_eq!(n_inf.clone().try_into() as Result<u8, ()>, Err(()));
464 assert_eq!(n_inf.clone().try_into() as Result<u16, ()>, Err(()));
465 assert_eq!(n_inf.clone().try_into() as Result<u32, ()>, Err(()));
466 assert_eq!(n_inf.clone().try_into() as Result<u64, ()>, Err(()));
467 assert_eq!(n_inf.clone().try_into() as Result<u128, ()>, Err(()));
468 assert_eq!(n_inf.clone().try_into() as Result<usize, ()>, Err(()));
469
470 assert_eq!(n_one.clone().try_into() as Result<u8, ()>, Err(()));
471 assert_eq!(n_one.clone().try_into() as Result<u16, ()>, Err(()));
472 assert_eq!(n_one.clone().try_into() as Result<u32, ()>, Err(()));
473 assert_eq!(n_one.clone().try_into() as Result<u64, ()>, Err(()));
474 assert_eq!(n_one.clone().try_into() as Result<u128, ()>, Err(()));
475 assert_eq!(n_one.clone().try_into() as Result<usize, ()>, Err(()));
476
477 assert_eq!(n_half.clone().try_into() as Result<u8, ()>, Err(()));
478 assert_eq!(n_half.clone().try_into() as Result<u16, ()>, Err(()));
479 assert_eq!(n_half.clone().try_into() as Result<u32, ()>, Err(()));
480 assert_eq!(n_half.clone().try_into() as Result<u64, ()>, Err(()));
481 assert_eq!(n_half.clone().try_into() as Result<u128, ()>, Err(()));
482 assert_eq!(n_half.clone().try_into() as Result<usize, ()>, Err(()));
483
484 assert_eq!(zero.clone().try_into(), Ok(0u8));
485 assert_eq!(zero.clone().try_into(), Ok(0u16));
486 assert_eq!(zero.clone().try_into(), Ok(0u32));
487 assert_eq!(zero.clone().try_into(), Ok(0u64));
488 assert_eq!(zero.clone().try_into(), Ok(0u128));
489 assert_eq!(zero.clone().try_into(), Ok(0usize));
490
491 assert_eq!(p_half.clone().try_into() as Result<u8, ()>, Err(()));
492 assert_eq!(p_half.clone().try_into() as Result<u16, ()>, Err(()));
493 assert_eq!(p_half.clone().try_into() as Result<u32, ()>, Err(()));
494 assert_eq!(p_half.clone().try_into() as Result<u64, ()>, Err(()));
495 assert_eq!(p_half.clone().try_into() as Result<u128, ()>, Err(()));
496 assert_eq!(p_half.clone().try_into() as Result<usize, ()>, Err(()));
497
498 assert_eq!(p_one.clone().try_into(), Ok(1u8));
499 assert_eq!(p_one.clone().try_into(), Ok(1u16));
500 assert_eq!(p_one.clone().try_into(), Ok(1u32));
501 assert_eq!(p_one.clone().try_into(), Ok(1u64));
502 assert_eq!(p_one.clone().try_into(), Ok(1u128));
503 assert_eq!(p_one.clone().try_into(), Ok(1usize));
504
505 assert_eq!(p_inf.clone().try_into() as Result<u8, ()>, Err(()));
506 assert_eq!(p_inf.clone().try_into() as Result<u16, ()>, Err(()));
507 assert_eq!(p_inf.clone().try_into() as Result<u32, ()>, Err(()));
508 assert_eq!(p_inf.clone().try_into() as Result<u64, ()>, Err(()));
509 assert_eq!(p_inf.clone().try_into() as Result<u128, ()>, Err(()));
510 assert_eq!(p_inf.clone().try_into() as Result<usize, ()>, Err(()));
511
512 assert_eq!(nan.clone().try_into() as Result<u8, ()>, Err(()));
513 assert_eq!(nan.clone().try_into() as Result<u16, ()>, Err(()));
514 assert_eq!(nan.clone().try_into() as Result<u32, ()>, Err(()));
515 assert_eq!(nan.clone().try_into() as Result<u64, ()>, Err(()));
516 assert_eq!(nan.clone().try_into() as Result<u128, ()>, Err(()));
517 assert_eq!(nan.clone().try_into() as Result<usize, ()>, Err(()));
518 }
519
520 #[cfg(feature = "with-bigint")]
521 #[test]
522 fn bigintdecimal_to_u() {
523 use crate::GenericDecimal;
524 use num::BigInt;
525
526 type BigDecimal = GenericDecimal<BigInt, u8>;
527
528 let n_inf = BigDecimal::neg_infinity();
529 let n_one = BigDecimal::one() * -1;
530 let n_half = n_one.clone() / 2;
531 let zero = BigDecimal::zero();
532 let p_one = BigDecimal::one();
533 let p_half = p_one.clone() / 2;
534 let p_inf = BigDecimal::infinity();
535 let nan = Decimal::nan();
536
537 assert_eq!(n_inf.clone().try_into() as Result<u8, ()>, Err(()));
538 assert_eq!(n_inf.clone().try_into() as Result<u16, ()>, Err(()));
539 assert_eq!(n_inf.clone().try_into() as Result<u32, ()>, Err(()));
540 assert_eq!(n_inf.clone().try_into() as Result<u64, ()>, Err(()));
541 assert_eq!(n_inf.clone().try_into() as Result<u128, ()>, Err(()));
542 assert_eq!(n_inf.clone().try_into() as Result<usize, ()>, Err(()));
543
544 assert_eq!(n_one.clone().try_into() as Result<u8, ()>, Err(()));
545 assert_eq!(n_one.clone().try_into() as Result<u16, ()>, Err(()));
546 assert_eq!(n_one.clone().try_into() as Result<u32, ()>, Err(()));
547 assert_eq!(n_one.clone().try_into() as Result<u64, ()>, Err(()));
548 assert_eq!(n_one.clone().try_into() as Result<u128, ()>, Err(()));
549 assert_eq!(n_one.clone().try_into() as Result<usize, ()>, Err(()));
550
551 assert_eq!(n_half.clone().try_into() as Result<u8, ()>, Err(()));
552 assert_eq!(n_half.clone().try_into() as Result<u16, ()>, Err(()));
553 assert_eq!(n_half.clone().try_into() as Result<u32, ()>, Err(()));
554 assert_eq!(n_half.clone().try_into() as Result<u64, ()>, Err(()));
555 assert_eq!(n_half.clone().try_into() as Result<u128, ()>, Err(()));
556 assert_eq!(n_half.clone().try_into() as Result<usize, ()>, Err(()));
557
558 assert_eq!(zero.clone().try_into(), Ok(0u8));
559 assert_eq!(zero.clone().try_into(), Ok(0u16));
560 assert_eq!(zero.clone().try_into(), Ok(0u32));
561 assert_eq!(zero.clone().try_into(), Ok(0u64));
562 assert_eq!(zero.clone().try_into(), Ok(0u128));
563 assert_eq!(zero.clone().try_into(), Ok(0usize));
564
565 assert_eq!(p_half.clone().try_into() as Result<u8, ()>, Err(()));
566 assert_eq!(p_half.clone().try_into() as Result<u16, ()>, Err(()));
567 assert_eq!(p_half.clone().try_into() as Result<u32, ()>, Err(()));
568 assert_eq!(p_half.clone().try_into() as Result<u64, ()>, Err(()));
569 assert_eq!(p_half.clone().try_into() as Result<u128, ()>, Err(()));
570 assert_eq!(p_half.clone().try_into() as Result<usize, ()>, Err(()));
571
572 assert_eq!(p_one.clone().try_into(), Ok(1u8));
573 assert_eq!(p_one.clone().try_into(), Ok(1u16));
574 assert_eq!(p_one.clone().try_into(), Ok(1u32));
575 assert_eq!(p_one.clone().try_into(), Ok(1u64));
576 assert_eq!(p_one.clone().try_into(), Ok(1u128));
577 assert_eq!(p_one.clone().try_into(), Ok(1usize));
578
579 assert_eq!(p_inf.clone().try_into() as Result<u8, ()>, Err(()));
580 assert_eq!(p_inf.clone().try_into() as Result<u16, ()>, Err(()));
581 assert_eq!(p_inf.clone().try_into() as Result<u32, ()>, Err(()));
582 assert_eq!(p_inf.clone().try_into() as Result<u64, ()>, Err(()));
583 assert_eq!(p_inf.clone().try_into() as Result<u128, ()>, Err(()));
584 assert_eq!(p_inf.clone().try_into() as Result<usize, ()>, Err(()));
585
586 assert_eq!(nan.clone().try_into() as Result<u8, ()>, Err(()));
587 assert_eq!(nan.clone().try_into() as Result<u16, ()>, Err(()));
588 assert_eq!(nan.clone().try_into() as Result<u32, ()>, Err(()));
589 assert_eq!(nan.clone().try_into() as Result<u64, ()>, Err(()));
590 assert_eq!(nan.clone().try_into() as Result<u128, ()>, Err(()));
591 assert_eq!(nan.clone().try_into() as Result<usize, ()>, Err(()));
592 }
593
594 #[cfg(feature = "with-bigint")]
595 #[test]
596 fn bigdecimal_to_f32() {
597 use crate::BigDecimal;
598
599 let n_inf = BigDecimal::neg_infinity();
600 let n_one = BigDecimal::one() * -1;
601 let n_half = n_one.clone() / 2;
602 let zero = BigDecimal::zero();
603 let p_one = BigDecimal::one();
604 let p_half = p_one.clone() / 2;
605 let p_inf = BigDecimal::infinity();
606 let nan = BigDecimal::nan();
607
608 assert_eq!(n_inf.try_into(), Ok(f32::NEG_INFINITY));
609 assert_eq!(n_one.try_into(), Ok(-1f32));
610 assert_eq!(n_half.try_into(), Ok(-0.5f32));
611 assert_eq!(zero.try_into(), Ok(0f32));
612 assert_eq!(p_half.try_into(), Ok(0.5f32));
613 assert_eq!(p_one.try_into(), Ok(1f32));
614 assert_eq!(p_inf.try_into(), Ok(f32::INFINITY));
615 assert!((nan.try_into() as Result<f32, ()>).unwrap_or(0f32).is_nan());
616 }
617
618 #[cfg(feature = "with-bigint")]
619 #[test]
620 fn bigintdecimal_to_f32() {
621 use crate::GenericDecimal;
622 use num::BigInt;
623
624 type BigDecimal = GenericDecimal<BigInt, u8>;
625
626 let n_inf = BigDecimal::neg_infinity();
627 let n_one = BigDecimal::one() * -1;
628 let n_half = n_one.clone() / 2;
629 let zero = BigDecimal::zero();
630 let p_one = BigDecimal::one();
631 let p_half = p_one.clone() / 2;
632 let p_inf = BigDecimal::infinity();
633 let nan = BigDecimal::nan();
634
635 assert_eq!(n_inf.try_into(), Ok(f32::NEG_INFINITY));
636 assert_eq!(n_one.try_into(), Ok(-1f32));
637 assert_eq!(n_half.try_into(), Ok(-0.5f32));
638 assert_eq!(zero.try_into(), Ok(0f32));
639 assert_eq!(p_half.try_into(), Ok(0.5f32));
640 assert_eq!(p_one.try_into(), Ok(1f32));
641 assert_eq!(p_inf.try_into(), Ok(f32::INFINITY));
642 assert!((nan.try_into() as Result<f32, ()>).unwrap_or(0f32).is_nan());
643 }
644
645 #[cfg(feature = "with-bigint")]
646 #[test]
647 fn bigdecimal_to_f64() {
648 use crate::BigDecimal;
649
650 let n_inf = BigDecimal::neg_infinity();
651 let n_one = BigDecimal::one() * -1;
652 let n_half = n_one.clone() / 2;
653 let zero = BigDecimal::zero();
654 let p_one = BigDecimal::one();
655 let p_half = p_one.clone() / 2;
656 let p_inf = BigDecimal::infinity();
657 let nan = BigDecimal::nan();
658
659 assert_eq!(n_inf.try_into(), Ok(f64::NEG_INFINITY));
660 assert_eq!(n_one.try_into(), Ok(-1f64));
661 assert_eq!(n_half.try_into(), Ok(-0.5f64));
662 assert_eq!(zero.try_into(), Ok(0f64));
663 assert_eq!(p_half.try_into(), Ok(0.5f64));
664 assert_eq!(p_one.try_into(), Ok(1f64));
665 assert_eq!(p_inf.try_into(), Ok(f64::INFINITY));
666 assert!((nan.try_into() as Result<f64, ()>).unwrap_or(0f64).is_nan());
667 }
668
669 #[cfg(feature = "with-bigint")]
670 #[test]
671 fn bigintdecimal_to_f64() {
672 use crate::GenericDecimal;
673 use num::BigInt;
674
675 type BigDecimal = GenericDecimal<BigInt, u8>;
676
677 let n_inf = BigDecimal::neg_infinity();
678 let n_one = BigDecimal::one() * -1;
679 let n_half = n_one.clone() / 2;
680 let zero = BigDecimal::zero();
681 let p_one = BigDecimal::one();
682 let p_half = p_one.clone() / 2;
683 let p_inf = BigDecimal::infinity();
684 let nan = BigDecimal::nan();
685
686 assert_eq!(n_inf.try_into(), Ok(f64::NEG_INFINITY));
687 assert_eq!(n_one.try_into(), Ok(-1f64));
688 assert_eq!(n_half.try_into(), Ok(-0.5f64));
689 assert_eq!(zero.try_into(), Ok(0f64));
690 assert_eq!(p_half.try_into(), Ok(0.5f64));
691 assert_eq!(p_one.try_into(), Ok(1f64));
692 assert_eq!(p_inf.try_into(), Ok(f64::INFINITY));
693 assert!((nan.try_into() as Result<f64, ()>).unwrap_or(0f64).is_nan());
694 }
695}