Skip to main content

mirascript_vm/value/types/
number.rs

1use super::{MiraValue, value::RawValue};
2use crate::{MiraError, Result, Runtime, TryFromMira};
3
4impl MiraValue {
5    /// Create a [`MiraValue`] representing a numeric value.
6    #[inline]
7    pub const fn number(value: f64) -> Self {
8        Self::from_raw(RawValue::from_number(value))
9    }
10
11    /// A [`MiraValue`] representing the numeric value `0.0`.
12    pub const ZERO: MiraValue = MiraValue::number(0.0);
13    /// A [`MiraValue`] representing the numeric value `1.0`.
14    pub const ONE: MiraValue = MiraValue::number(1.0);
15    /// A [`MiraValue`] representing the numeric value `-1.0`.
16    pub const NEGATIVE_ONE: MiraValue = MiraValue::number(-1.0);
17    /// A [`MiraValue`] representing the numeric value `f64::NAN`.
18    pub const NAN: MiraValue = MiraValue::number(f64::NAN);
19
20    /// Check whether this value is a numeric value.
21    #[inline]
22    pub const fn is_number(&self) -> bool {
23        self.tag().is_none()
24    }
25
26    /// Return the inline numeric payload, or [`None`] for another value type.
27    #[inline]
28    pub const fn as_number(&self) -> Option<f64> {
29        if self.is_number() {
30            Some(self.as_number_unchecked())
31        } else {
32            None
33        }
34    }
35    /// Return the inline numeric payload.
36    #[inline]
37    pub const fn as_number_unchecked(self) -> f64 {
38        debug_assert!(self.is_number(), "MiraValue is not a number");
39        self.raw().number()
40    }
41}
42
43macro_rules! number_from {
44    ($($ty:ty),* $(,)?) => {$ (
45        impl From<$ty> for MiraValue {
46            fn from(value: $ty) -> Self {
47                Self::number(value as f64)
48            }
49        }
50    )* };
51}
52
53number_from!(
54    u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, f32, f64
55);
56
57macro_rules! integer_try_from {
58    ($($ty:ty),* $(,)?) => {$ (
59        impl TryFrom<MiraValue> for $ty {
60            type Error = Box<MiraError>;
61
62            fn try_from(value: MiraValue) -> Result<Self> {
63                let Some(number) = value.as_number() else {
64                    return Err(MiraError::conversion_type(stringify!($ty), value.value_type()));
65                };
66                if !number.is_finite()
67                    || number.trunc() != number
68                    || number < (<$ty>::MIN as f64)
69                    || number > (<$ty>::MAX as f64)
70                {
71                    return Err(MiraError::conversion_number(stringify!($ty), number));
72                }
73                Ok(number as $ty)
74            }
75        }
76
77        impl TryFromMira<'_> for $ty {
78            fn from_mira(_runtime: &Runtime, value: MiraValue) -> Result<Self> {
79                Self::try_from(value)
80            }
81        }
82    )* };
83}
84integer_try_from!(
85    u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize
86);
87
88impl TryFrom<MiraValue> for f64 {
89    type Error = Box<MiraError>;
90
91    fn try_from(value: MiraValue) -> Result<Self> {
92        value
93            .as_number()
94            .ok_or_else(|| MiraError::conversion_type("f64", value.value_type()))
95    }
96}
97
98impl TryFromMira<'_> for f64 {
99    fn from_mira(_runtime: &Runtime, value: MiraValue) -> Result<Self> {
100        f64::try_from(value)
101    }
102}
103
104impl TryFrom<MiraValue> for f32 {
105    type Error = Box<MiraError>;
106
107    fn try_from(value: MiraValue) -> Result<Self> {
108        let value = f64::try_from(value)?;
109        if value.is_finite() && (value < f32::MIN as f64 || value > f32::MAX as f64) {
110            return Err(MiraError::conversion_number("f32", value));
111        }
112        Ok(value as f32)
113    }
114}
115
116impl TryFromMira<'_> for f32 {
117    fn from_mira(_runtime: &Runtime, value: MiraValue) -> Result<Self> {
118        f32::try_from(value)
119    }
120}
121
122#[cfg(test)]
123mod tests {
124
125    use super::*;
126
127    #[test]
128    fn test_number() {
129        assert_eq!(MiraValue::number(42.0), MiraValue::number(42.0));
130    }
131
132    #[test]
133    fn test_number_is_number() {
134        assert!(MiraValue::number(42.0).is_number());
135        assert!(!MiraValue::NIL.is_number());
136    }
137
138    #[test]
139    fn test_number_as_number() {
140        assert_eq!(MiraValue::number(42.0).as_number(), Some(42.0));
141        assert_eq!(MiraValue::NIL.as_number(), None);
142    }
143
144    #[test]
145    fn test_number_try_from() {
146        let value = MiraValue::number(42.0);
147        assert_eq!(u8::try_from(value).unwrap(), 42u8);
148        assert_eq!(i32::try_from(value).unwrap(), 42i32);
149        assert_eq!(u128::try_from(value).unwrap(), 42u128);
150        assert_eq!(f32::try_from(value).unwrap(), 42f32);
151        assert_eq!(f64::try_from(value).unwrap(), 42f64);
152    }
153    #[test]
154    fn test_number_from_mira() {
155        let runtime = Runtime::new();
156        let value = MiraValue::number(42.0);
157        assert_eq!(u8::from_mira(&runtime, value).unwrap(), 42u8);
158        assert_eq!(i32::from_mira(&runtime, value).unwrap(), 42i32);
159        assert_eq!(u128::from_mira(&runtime, value).unwrap(), 42u128);
160        assert_eq!(f32::from_mira(&runtime, value).unwrap(), 42f32);
161        assert_eq!(f64::from_mira(&runtime, value).unwrap(), 42f64);
162    }
163    #[test]
164    fn test_number_try_from_underflow() {
165        let value = MiraValue::number(-1.0);
166        assert!(u8::try_from(value).is_err());
167        assert!(u32::try_from(value).is_err());
168        assert!(u128::try_from(value).is_err());
169    }
170
171    #[test]
172    fn test_number_try_from_overflow() {
173        let value = MiraValue::number(256.0);
174
175        assert!(dbg!(u8::try_from(value)).is_err());
176        let value = MiraValue::number(u32::MAX as f64 * 1.1);
177        assert!(dbg!(u32::try_from(value)).is_err());
178        let value = MiraValue::number(u128::MAX as f64 * 1.1);
179        assert!(dbg!(u128::try_from(value)).is_err());
180        let value = MiraValue::number(f32::MAX as f64 * 1.1);
181        assert!(f32::try_from(value).is_err());
182    }
183
184    #[test]
185    fn test_number_try_from_non_integer() {
186        let value = MiraValue::number(42.5);
187        assert!(u8::try_from(value).is_err());
188        assert!(i32::try_from(value).is_err());
189        assert!(u128::try_from(value).is_err());
190    }
191
192    #[test]
193    fn test_number_try_from_non_finite() {
194        let value = MiraValue::number(f64::INFINITY);
195        assert!(u8::try_from(value).is_err());
196        assert!(i32::try_from(value).is_err());
197        assert!(u128::try_from(value).is_err());
198        let value = MiraValue::number(f64::NAN);
199        assert!(u8::try_from(value).is_err());
200        assert!(i32::try_from(value).is_err());
201        assert!(u128::try_from(value).is_err());
202    }
203
204    #[test]
205    fn test_number_try_from_non_number() {
206        assert!(f64::try_from(MiraValue::NIL).is_err());
207
208        let value = MiraValue::boolean(true);
209        assert!(u8::try_from(value).is_err());
210        assert!(i32::try_from(value).is_err());
211        assert!(u128::try_from(value).is_err());
212
213        let value = MiraValue::str(&"42");
214        assert!(u8::try_from(value).is_err());
215        assert!(f64::try_from(value).is_err());
216    }
217
218    #[test]
219    fn test_number_try_from_negative_zero() {
220        let value = MiraValue::number(-0.0);
221        assert_eq!(u8::try_from(value).unwrap(), 0u8);
222        assert_eq!(i32::try_from(value).unwrap(), 0i32);
223        assert_eq!(u128::try_from(value).unwrap(), 0u128);
224        assert_eq!(f32::try_from(value).unwrap(), -0.0f32);
225        assert_eq!(f64::try_from(value).unwrap(), -0.0f64);
226    }
227
228    #[test]
229    fn test_number_into() {
230        assert_eq!(MiraValue::from(42u8), MiraValue::number(42.0));
231        assert_eq!(MiraValue::from(42i32), MiraValue::number(42.0));
232        assert_eq!(MiraValue::from(42u128), MiraValue::number(42.0));
233        assert_eq!(MiraValue::from(42f32), MiraValue::number(42.0));
234        assert_eq!(MiraValue::from(42f64), MiraValue::number(42.0));
235    }
236}