devela/num/traits/
constants.rs

Help
1// devela::num::traits::constants
2//
3//! Defines `ExtNumConst` and implements it for primitives.
4//
5// WIP > https://chatgpt.com/c/67bda660-8604-8007-8d87-97bc66b63082
6// IMPROVE:
7// - add NUM_MAX_POWER_OF_THREE maybe pre-compute
8
9use crate::{
10    unwrap, ExtFloatConst, NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8,
11    NonZeroIsize, NonZeroU128, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize,
12};
13
14/// Fundamental numeric constants for both integer and floating-point types.
15pub trait ExtNumConst {
16    /// The underlying numeric type implementing this trait.
17    type Num;
18
19    /// The additive identity (`0`), if applicable.
20    const NUM_ZERO: Option<Self::Num>;
21
22    /// The multiplicative identity (`1`).
23    const NUM_ONE: Self::Num;
24
25    /// The only even prime and the fundamental doubling factor (`2`).
26    const NUM_TWO: Self::Num;
27
28    /// The smallest odd prime and the first nontrivial divisor (`3`).
29    const NUM_THREE: Self::Num;
30
31    /// The additive inverse of `ONE` (`-1`), if applicable.
32    const NUM_NEG_ONE: Option<Self::Num>;
33
34    /// The smallest representable positive value.
35    const NUM_MIN_POSITIVE: Self::Num;
36
37    /// The greatest representable negative value, if applicable.
38    const NUM_MAX_NEGATIVE: Option<Self::Num>;
39
40    /// The maximum power of two within the type’s range.
41    const NUM_MAX_POWER_OF_TWO: Self::Num;
42}
43
44///
45macro_rules! impl_ext_num_const {
46    () => {
47        impl_ext_num_const![float: f32|u32, f64|u64];
48        impl_ext_num_const![int: i8|u8, i16|u16, i32|u32, i64|u64, i128|u128, isize|usize];
49        impl_ext_num_const![uint: u8|u8, u16|u16, u32|u32, u64|u64, u128|u128, usize|usize];
50        impl_ext_num_const![non0int: NonZeroI8|u8, NonZeroI16|u16, NonZeroI32|u32,
51            NonZeroI64|u64, NonZeroI128|u128, NonZeroIsize|usize];
52        impl_ext_num_const![non0uint: NonZeroU8|u8, NonZeroU16|u16, NonZeroU32|u32,
53            NonZeroU64|u64, NonZeroU128|u128, NonZeroUsize|usize];
54    };
55    ($T:ty | $U:ty: $ZERO:expr, $ONE:expr, $TWO:expr, $THREE:expr,
56     $NEG_ONE:expr, $MIN_POS:expr, $MAX_NEG:expr, $MAX_POW2:expr) => {
57        impl_ext_num_const![@$T|$U: $ZERO, $ONE, $TWO, $THREE,
58        $NEG_ONE, $MIN_POS, $MAX_NEG, $MAX_POW2];
59    };
60    (@$T:ty | $U:ty: $ZERO:expr, $ONE:expr, $TWO:expr, $THREE:expr,
61     $NEG_ONE:expr, $MIN_POS:expr, $MAX_NEG:expr, $MAX_POW2:expr) => {
62        impl ExtNumConst for $T {
63            type Num = $T;
64            const NUM_ZERO: Option<$T> = $ZERO;
65            const NUM_ONE: $T = $ONE;
66            const NUM_TWO: $T = $TWO;
67            const NUM_THREE: $T = $THREE;
68            const NUM_NEG_ONE: Option<$T> = $NEG_ONE;
69            const NUM_MIN_POSITIVE: $T = $MIN_POS;
70            const NUM_MAX_NEGATIVE: Option<$T> = $MAX_NEG;
71            const NUM_MAX_POWER_OF_TWO: $T = $MAX_POW2;
72        }
73    };
74
75    /* specific impls */
76
77    (float: $( $T:ty | $U:ty ),+) => { $(
78        impl_ext_num_const![$T|$U:
79            Some(0.0), 1.0, 2.0, 3.0,
80            Some(-1.0),         // NEG_ONE
81            <$T>::MIN_POSITIVE, // MIN_POS
82            Some(-0.0),         // MAX_NEG // ↓ MAX_POW2
83            <$T>::from_bits(((<$T>::EXPONENT_BIAS as $U << 1) << (<$T>::SIGNIFICAND_BITS)))
84        ];
85    )+};
86    (int: $( $T:ty | $U:ty ),+) => { $(
87        impl_ext_num_const![$T|$U:
88            Some(0), 1, 2, 3,
89            Some(-1),   // NEG_ONE
90            1,          // MIN_POS
91            Some(-1),   // MAX_NEG
92            <$T>::MAX - (<$T>::MAX >> 1) // MAX_POW2
93        ];
94    )+};
95    (uint: $( $T:ty | $U:ty ),+) => { $(
96        impl_ext_num_const![$T|$U:
97            Some(0), 1, 2, 3,
98            None,   // NEG_ONE
99            1,      // MIN_POS
100            None,   // MAX_NEG
101            <$T>::MAX ^ (<$T>::MAX >> 1) // MAX_POW2
102          ];
103    )+};
104    (non0int: $( $T:ty | $U:ty ),+) => { $(
105        impl_ext_num_const![$T|$U:
106            None,
107            unwrap![some <$T>::new(1)],
108            unwrap![some <$T>::new(2)],
109            unwrap![some <$T>::new(3)],
110            <$T>::new(-1),              // NEG_ONE
111            unwrap![some <$T>::new(1)], // MIN_POS
112            <$T>::new(-1),              // MAX_NEG
113            unwrap![some <$T>::new(<$T>::MAX.get() - (<$T>::MAX.get() >> 1))] // MAX_POW2
114        ];
115    )+};
116    (non0uint: $( $T:ty | $U:ty ),+) => { $(
117        impl_ext_num_const![$T|$U:
118            None,
119            unwrap![some <$T>::new(1)],
120            unwrap![some <$T>::new(2)],
121            unwrap![some <$T>::new(3)],
122            None,                       // NEG_ONE
123            unwrap![some <$T>::new(1)], // MIN_POS
124            None,                       // MAX_NEG
125            unwrap![some <$T>::new(<$T>::MAX.get() ^ (<$T>::MAX.get() >> 1))] // MAX_POW2
126        ];
127    )+};
128}
129impl_ext_num_const![];
130
131#[cfg(test)]
132mod tests {
133    use super::{ExtFloatConst, ExtNumConst, NonZeroI8, NonZeroU8};
134
135    #[test]
136    fn float() {
137        assert_eq!(f32::NUM_ZERO, Some(0.0));
138        assert_eq!(f32::NUM_ONE, 1.0);
139        assert_eq!(f32::NUM_TWO, 2.0);
140        assert_eq!(f32::NUM_THREE, 3.0);
141        assert_eq!(f32::NUM_NEG_ONE, Some(-1.0));
142        assert_eq!(f32::NUM_MIN_POSITIVE, f32::MIN_POSITIVE);
143        assert_eq!(f32::NUM_MAX_NEGATIVE, Some(-0.0));
144        assert_eq!(f32::NUM_MAX_POWER_OF_TWO, 2.0_f32.powi(f32::EXPONENT_BIAS as i32));
145        assert_eq!(f64::NUM_MAX_POWER_OF_TWO, 2.0_f64.powi(f64::EXPONENT_BIAS as i32));
146    }
147    #[test]
148    fn int() {
149        assert_eq!(i8::NUM_ZERO, Some(0));
150        assert_eq!(i8::NUM_ONE, 1);
151        assert_eq!(i8::NUM_TWO, 2);
152        assert_eq!(i8::NUM_THREE, 3);
153        assert_eq!(i8::NUM_NEG_ONE, Some(-1));
154        assert_eq!(i8::NUM_MIN_POSITIVE, 1);
155        assert_eq!(i8::NUM_MAX_NEGATIVE, Some(-1));
156        assert_eq!(i8::NUM_MAX_POWER_OF_TWO, 64);
157    }
158    #[test]
159    fn uint() {
160        assert_eq!(u8::NUM_ZERO, Some(0));
161        assert_eq!(u8::NUM_ONE, 1);
162        assert_eq!(u8::NUM_TWO, 2);
163        assert_eq!(u8::NUM_THREE, 3);
164        assert_eq!(u8::NUM_NEG_ONE, None);
165        assert_eq!(u8::NUM_MIN_POSITIVE, 1);
166        assert_eq!(u8::NUM_MAX_NEGATIVE, None);
167        assert_eq!(u8::NUM_MAX_POWER_OF_TWO, 128);
168    }
169    #[test]
170    fn non0int() {
171        assert_eq!(NonZeroI8::NUM_ZERO, None);
172        assert_eq!(NonZeroI8::NUM_ONE, NonZeroI8::new(1).unwrap());
173        assert_eq!(NonZeroI8::NUM_TWO, NonZeroI8::new(2).unwrap());
174        assert_eq!(NonZeroI8::NUM_THREE, NonZeroI8::new(3).unwrap());
175        assert_eq!(NonZeroI8::NUM_NEG_ONE, Some(NonZeroI8::new(-1).unwrap()));
176        assert_eq!(NonZeroI8::NUM_MIN_POSITIVE, NonZeroI8::new(1).unwrap());
177        assert_eq!(NonZeroI8::NUM_MAX_NEGATIVE, Some(NonZeroI8::new(-1).unwrap()));
178        assert_eq!(NonZeroI8::NUM_MAX_POWER_OF_TWO, NonZeroI8::new(64).unwrap());
179    }
180    #[test]
181    fn non0uint() {
182        assert_eq!(NonZeroU8::NUM_ZERO, None);
183        assert_eq!(NonZeroU8::NUM_ONE, NonZeroU8::new(1).unwrap());
184        assert_eq!(NonZeroU8::NUM_TWO, NonZeroU8::new(2).unwrap());
185        assert_eq!(NonZeroU8::NUM_THREE, NonZeroU8::new(3).unwrap());
186        assert_eq!(NonZeroU8::NUM_NEG_ONE, None);
187        assert_eq!(NonZeroU8::NUM_MIN_POSITIVE, NonZeroU8::new(1).unwrap());
188        assert_eq!(NonZeroU8::NUM_MAX_NEGATIVE, None);
189        assert_eq!(NonZeroU8::NUM_MAX_POWER_OF_TWO, NonZeroU8::new(128).unwrap());
190    }
191}
devela/num/traits/constants.rs

devela/num/traits/
constants.rs
