artichoke_backend/extn/core/float/
mod.rs

1use std::fmt;
2
3use crate::extn::core::numeric::{self, Coercion, Outcome};
4use crate::extn::prelude::*;
5
6pub(in crate::extn) mod mruby;
7
8#[repr(transparent)]
9#[derive(Default, Clone, Copy, PartialEq, PartialOrd)]
10pub struct Float(f64);
11
12impl fmt::Debug for Float {
13    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14        self.0.fmt(f)
15    }
16}
17
18impl fmt::Display for Float {
19    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
20        self.0.fmt(f)
21    }
22}
23
24impl ConvertMut<Float, Value> for Artichoke {
25    #[inline]
26    fn convert_mut(&mut self, from: Float) -> Value {
27        self.convert_mut(from.0)
28    }
29}
30
31impl TryConvert<Value, Float> for Artichoke {
32    type Error = Error;
33
34    #[inline]
35    fn try_convert(&self, value: Value) -> Result<Float, Self::Error> {
36        let num = self.try_convert(value)?;
37        Ok(Float(num))
38    }
39}
40
41impl From<f64> for Float {
42    #[inline]
43    fn from(flt: f64) -> Self {
44        Self(flt)
45    }
46}
47
48impl From<Float> for f64 {
49    #[inline]
50    fn from(flt: Float) -> Self {
51        flt.as_f64()
52    }
53}
54
55impl From<Float> for Outcome {
56    #[inline]
57    fn from(flt: Float) -> Self {
58        Self::Float(flt.into())
59    }
60}
61
62impl From<f64> for Outcome {
63    #[inline]
64    fn from(flt: f64) -> Self {
65        Self::Float(flt)
66    }
67}
68
69impl Float {
70    /// The minimum number of significant decimal digits in a double-precision
71    /// floating point.
72    ///
73    /// Usually defaults to 15.
74    pub const DIG: i64 = f64::DIGITS as i64;
75
76    /// The difference between 1 and the smallest double-precision floating
77    /// point number greater than 1.
78    ///
79    /// Usually defaults to 2.2204460492503131e-16.
80    pub const EPSILON: f64 = f64::EPSILON;
81
82    /// An expression representing positive infinity.
83    pub const INFINITY: f64 = f64::INFINITY;
84
85    /// The minimum number of significant decimal digits in a double-precision
86    /// floating point.
87    ///
88    /// Usually defaults to 15.
89    pub const MANT_DIG: i64 = f64::MANTISSA_DIGITS as i64;
90
91    /// The largest possible integer in a double-precision floating point
92    /// number.
93    ///
94    /// Usually defaults to `1.7976931348623157e+308`.
95    pub const MAX: f64 = f64::MAX;
96
97    /// The largest positive exponent in a double-precision floating point where
98    /// 10 raised to this power minus 1.
99    ///
100    /// Usually defaults to 308.
101    pub const MAX_10_EXP: i64 = f64::MAX_10_EXP as i64;
102
103    /// The largest possible exponent value in a double-precision floating
104    /// point.
105    ///
106    /// Usually defaults to 1024.
107    pub const MAX_EXP: i64 = f64::MAX_EXP as i64;
108
109    /// The smallest positive normalized number in a double-precision floating
110    /// point.
111    ///
112    /// Usually defaults to 2.2250738585072014e-308.
113    ///
114    /// If the platform supports denormalized numbers, there are numbers between
115    /// zero and [`Float::MIN`]. `0.0.next_float` returns the smallest positive
116    /// floating point number including denormalized numbers.
117    pub const MIN: f64 = f64::MIN;
118
119    /// The smallest negative exponent in a double-precision floating point
120    /// where 10 raised to this power minus 1.
121    ///
122    /// Usually defaults to -307.
123    pub const MIN_10_EXP: i64 = f64::MIN_10_EXP as i64;
124
125    /// The smallest possible exponent value in a double-precision floating
126    /// point.
127    ///
128    /// Usually defaults to -1021.
129    pub const MIN_EXP: i64 = f64::MIN_EXP as i64;
130
131    /// An expression representing a value which is "not a number".
132    pub const NAN: f64 = f64::NAN;
133
134    pub const NEG_INFINITY: f64 = f64::NEG_INFINITY;
135
136    /// The base of the floating point, or number of unique digits used to
137    /// represent the number.
138    ///
139    /// Usually defaults to 2 on most systems, which would represent a base-10
140    /// decimal.
141    pub const RADIX: i64 = f64::RADIX as i64;
142
143    /// Represents the rounding mode for floating point addition.
144    ///
145    /// Usually defaults to 1, rounding to the nearest number.
146    ///
147    /// Other modes include:
148    ///
149    /// | mode                               | value |
150    /// |------------------------------------|-------|
151    /// | Indeterminable                     | -1    |
152    /// | Rounding towards zero              | 0     |
153    /// | Rounding to the nearest number     | 1     |
154    /// | Rounding towards positive infinity | 2     |
155    /// | Rounding towards negative infinity | 3     |
156    ///
157    /// # Rust Caveats
158    ///
159    /// Rust does not support setting the rounding mode and the behavior from
160    /// LLVM is not documented.  Because of this uncertainty, Artichoke sets its
161    /// rounding mode to `-1`, Indeterminable.
162    ///
163    /// The Rust docs say [`f64::round`][round] rounds "half-way cases away from
164    /// 0.0." Stack Overflow has a
165    /// [discussion around float rounding semantics][stackoverflow] in Rust and
166    /// LLVM.
167    ///
168    /// [stackoverflow]: https://stackoverflow.com/a/28122536
169    /// [round]: https://doc.rust-lang.org/1.42.0/std/primitive.f64.html#method.round
170    pub const ROUNDS: i64 = -1;
171
172    /// Construct a new, zero, float.
173    #[inline]
174    #[must_use]
175    pub const fn new() -> Self {
176        Self(0.0)
177    }
178
179    /// Construct a new `Float` with a given [`f64`].
180    #[inline]
181    #[must_use]
182    pub const fn with_f64(f: f64) -> Self {
183        Self(f)
184    }
185
186    /// Convert self to an `i64` with a saturating cast.
187    #[inline]
188    #[must_use]
189    #[expect(clippy::cast_possible_truncation, reason = "Ruby Float#to_i intentionally truncates")]
190    pub const fn as_i64(self) -> i64 {
191        self.0 as i64
192    }
193
194    /// Return the inner [`f64`].
195    #[inline]
196    #[must_use]
197    pub const fn as_f64(self) -> f64 {
198        self.0
199    }
200
201    #[inline]
202    #[must_use]
203    #[expect(
204        clippy::cast_precision_loss,
205        clippy::cast_possible_truncation,
206        reason = "consts are in f64 lossless range"
207    )]
208    pub fn try_into_fixnum(self) -> Option<i64> {
209        const FIXABLE_MAX: f64 = 2_i64.pow(f64::MANTISSA_DIGITS) as f64;
210        const FIXABLE_MIN: f64 = -(2_i64.pow(f64::MANTISSA_DIGITS)) as f64;
211
212        match self.0 {
213            x if !x.is_finite() => None,
214            x if x > FIXABLE_MAX => None,
215            x if x < FIXABLE_MIN => None,
216            x => Some(x as i64),
217        }
218    }
219
220    /// Compute the remainder of self and other.
221    ///
222    /// Equivalent to `self.as_f64() % other.as_f64()`.
223    #[inline]
224    #[must_use]
225    pub fn modulo(self, other: Self) -> Self {
226        Self(self.0 % other.0)
227    }
228
229    #[inline]
230    pub fn coerced_modulo(self, interp: &mut Artichoke, other: Value) -> Result<Outcome, Error> {
231        if let Ruby::Float = other.ruby_type() {
232            let other = other.try_convert_into::<Float>(interp)?;
233            return Ok(self.modulo(other).into());
234        }
235        let x = interp.convert_mut(self);
236        let coerced = numeric::coerce(interp, x, other)?;
237        match coerced {
238            Coercion::Float(x, y) => Ok((x % y).into()),
239            Coercion::Integer(x, y) => Ok((x % y).into()),
240        }
241    }
242}
artichoke_backend/extn/core/float/mod.rs

artichoke_backend/extn/core/float/
mod.rs
