typed_floats/types/impls/from_to/
floats.rs

1use crate::{
2    InvalidNumber, Negative, NegativeFinite, NonNaN, NonNaNFinite, NonZeroNonNaN,
3    NonZeroNonNaNFinite, Positive, PositiveFinite, StrictlyNegative, StrictlyNegativeFinite,
4    StrictlyPositive, StrictlyPositiveFinite,
5};
6
7macro_rules! impl_from {
8    ($test:ident, $type:ident) => {
9        impl From<$type<Self>> for f32 {
10            #[inline]
11            fn from(value: $type<Self>) -> Self {
12                value.0
13            }
14        }
15
16        impl From<$type<Self>> for f64 {
17            #[inline]
18            fn from(value: $type<Self>) -> Self {
19                value.0
20            }
21        }
22
23        impl TryFrom<f32> for $type<f32> {
24            type Error = InvalidNumber;
25
26            #[inline]
27            fn try_from(value: f32) -> Result<Self, Self::Error> {
28                Self::new(value)
29            }
30        }
31
32        impl TryFrom<f64> for $type<f64> {
33            type Error = InvalidNumber;
34
35            #[inline]
36            fn try_from(value: f64) -> Result<Self, Self::Error> {
37                Self::new(value)
38            }
39        }
40
41        #[test]
42        fn $test() {
43            let values_f32 = crate::tf32::get_test_values();
44
45            for &value in &values_f32 {
46                if let Ok(t) = $type::<f32>::new(value) {
47                    crate::assert_float_eq!(value, t.get());
48                    assert_eq!(t, unsafe { $type::<f32>::new_unchecked(value) });
49                }
50            }
51
52            let values_f64 = crate::tf64::get_test_values();
53
54            for &value in &values_f64 {
55                if let Ok(t) = $type::<f64>::new(value) {
56                    crate::assert_float_eq!(value, t.get());
57                    assert_eq!(t, unsafe { $type::<f64>::new_unchecked(value) });
58                }
59            }
60        }
61    };
62}
63
64impl_from!(non_nan, NonNaN);
65impl_from!(non_zero_non_nan, NonZeroNonNaN);
66impl_from!(non_nan_finite, NonNaNFinite);
67impl_from!(non_zero_non_nan_finite, NonZeroNonNaNFinite);
68impl_from!(positive, Positive);
69impl_from!(negative, Negative);
70impl_from!(positive_finite, PositiveFinite);
71impl_from!(negative_finite, NegativeFinite);
72impl_from!(strictly_positive, StrictlyPositive);
73impl_from!(strictly_negative, StrictlyNegative);
74impl_from!(strictly_positive_finite, StrictlyPositiveFinite);
75impl_from!(strictly_negative_finite, StrictlyNegativeFinite);