Skip to main content

libc_rs/
math.rs

1//! Pure-Rust `#![no_std]` IEEE-754 floating-point intrinsics.
2
3const LN2_HI: f64 = 6.931_471_803_691_238e-1;
4const LN2_LO: f64 = 1.908_214_929_270_587_7e-10;
5const INV_LN2: f64 = core::f64::consts::LOG2_E;
6
7const LG1: f64 = 6.666_666_666_666_735e-1;
8const LG2: f64 = 3.999_999_999_940_942e-1;
9const LG3: f64 = 2.857_142_874_366_239e-1;
10const LG4: f64 = 2.222_219_843_214_978_4e-1;
11const LG5: f64 = 1.818_357_216_161_805e-1;
12const LG6: f64 = 1.531_383_769_920_937_3e-1;
13const LG7: f64 = 1.479_819_860_511_658_6e-1;
14
15const EXP_P1: f64 = 1.666_666_666_666_660_2e-1;
16const EXP_P2: f64 = -2.777_777_777_701_559_3e-3;
17const EXP_P3: f64 = 6.613_756_321_437_934e-5;
18const EXP_P4: f64 = -1.653_390_220_546_525_2e-6;
19const EXP_P5: f64 = 4.138_136_797_057_238_5e-8;
20
21/// Returns the largest integer less than or equal to `x`.
22#[must_use]
23#[inline]
24pub fn floor(x: f64) -> f64 {
25    if x.is_nan() || x.is_infinite() || x == 0.0 {
26        return x;
27    }
28    let t = trunc(x);
29    if x < t { t - 1.0 } else { t }
30}
31
32/// Returns the smallest integer greater than or equal to `x`.
33#[must_use]
34#[inline]
35pub fn ceil(x: f64) -> f64 {
36    if x.is_nan() || x.is_infinite() || x == 0.0 {
37        return x;
38    }
39    let t = trunc(x);
40    if x > t { t + 1.0 } else { t }
41}
42
43/// Returns the integer part of `x`, rounding toward zero.
44#[must_use]
45#[inline]
46pub fn trunc(x: f64) -> f64 {
47    let bits = x.to_bits();
48    let exp = ((bits >> 52) & 0x7ff) as i32 - 1023;
49    if exp < 0 {
50        return f64::from_bits(bits & (1u64 << 63));
51    }
52    if exp >= 52 {
53        return x;
54    }
55    let mask = (1u64 << (52 - exp)) - 1;
56    f64::from_bits(bits & !mask)
57}
58
59#[inline(always)]
60fn ln_pos_normal(ux: u64) -> f64 {
61    let mut k = ((ux >> 52) as i32) - 1023;
62    let mant_hi = ((ux >> 32) as u32) & 0x000f_ffff;
63    let offset = (mant_hi + 0x95f64) & 0x0010_0000;
64    let m_bits = (ux & 0x000f_ffff_ffff_ffff) | (((offset ^ 0x3ff0_0000) as u64) << 32);
65    k += (offset >> 20) as i32;
66
67    let f = f64::from_bits(m_bits) - 1.0;
68    let s = f / (2.0 + f);
69    let z = s * s;
70    let w = z * z;
71    let t1 = w * (LG2 + w * (LG4 + w * LG6));
72    let t2 = z * (LG1 + w * (LG3 + w * (LG5 + w * LG7)));
73    let r = t2 + t1;
74    let hfsq = 0.5 * f * f;
75    let dk = k as f64;
76
77    dk * LN2_HI - ((hfsq - (s * (hfsq + r) + dk * LN2_LO)) - f)
78}
79
80#[cold]
81#[inline(never)]
82fn ln_special(x: f64) -> f64 {
83    if x.is_nan() || x < 0.0 {
84        return f64::NAN;
85    }
86    if x == 0.0 {
87        return f64::NEG_INFINITY;
88    }
89    if x == f64::INFINITY {
90        return f64::INFINITY;
91    }
92    if x == 1.0 {
93        return 0.0;
94    }
95    let ux = (x * ((1u64 << 52) as f64)).to_bits();
96    let mut k = ((ux >> 52) as i32) - 1023 - 52;
97    let mant_hi = ((ux >> 32) as u32) & 0x000f_ffff;
98    let offset = (mant_hi + 0x95f64) & 0x0010_0000;
99    let m_bits = (ux & 0x000f_ffff_ffff_ffff) | (((offset ^ 0x3ff0_0000) as u64) << 32);
100    k += (offset >> 20) as i32;
101
102    let f = f64::from_bits(m_bits) - 1.0;
103    let s = f / (2.0 + f);
104    let z = s * s;
105    let w = z * z;
106    let t1 = w * (LG2 + w * (LG4 + w * LG6));
107    let t2 = z * (LG1 + w * (LG3 + w * (LG5 + w * LG7)));
108    let r = t2 + t1;
109    let hfsq = 0.5 * f * f;
110    let dk = k as f64;
111
112    dk * LN2_HI - ((hfsq - (s * (hfsq + r) + dk * LN2_LO)) - f)
113}
114
115/// Computes the natural logarithm $\ln(x)$ using the FDLIBM minimax approximation.
116#[must_use]
117#[inline]
118pub fn ln(x: f64) -> f64 {
119    let ux = x.to_bits();
120    if ux.wrapping_sub(0x0010_0000_0000_0000) < 0x7fe0_0000_0000_0000 && ux != 0x3ff0_0000_0000_0000
121    {
122        return ln_pos_normal(ux);
123    }
124    ln_special(x)
125}
126
127/// Computes $e^x$ using the FDLIBM range reduction and Remez rational approximation.
128#[inline]
129fn exp(x: f64) -> f64 {
130    if x.is_nan() {
131        return f64::NAN;
132    }
133    if x > 709.782_712_893_384 {
134        return f64::INFINITY;
135    }
136    if x < -745.133_219_101_941_1 {
137        return 0.0;
138    }
139    if x == 0.0 {
140        return 1.0;
141    }
142
143    let k = (x * INV_LN2 + if x >= 0.0 { 0.5 } else { -0.5 }) as i32;
144    let dk = k as f64;
145    let hi = x - dk * LN2_HI;
146    let lo = dk * LN2_LO;
147    let r = hi - lo;
148    let z = r * r;
149    let c = r - z * (EXP_P1 + z * (EXP_P2 + z * (EXP_P3 + z * (EXP_P4 + z * EXP_P5))));
150    let y = 1.0 - ((lo - (r * c) / (2.0 - c)) - hi);
151
152    scale_pow2(y, k)
153}
154
155#[inline]
156fn scale_pow2(y: f64, k: i32) -> f64 {
157    if (-1021..=1023).contains(&k) {
158        return y * f64::from_bits(((k + 1023) as u64) << 52);
159    }
160    if k == 1024 {
161        return (y * f64::from_bits(2046u64 << 52)) * 2.0;
162    }
163    // Subnormal range (k < -1021): scale in two steps.
164    let k1 = -1022;
165    let k2 = k - k1;
166    (y * f64::from_bits(((k1 + 1023) as u64) << 52)) * f64::from_bits(((k2 + 1023) as u64) << 52)
167}
168
169/// classifies finite `y`: `0` = non-integer, `1` = odd integer, `2` = even integer.
170#[inline]
171fn classify_integer(y: f64) -> u8 {
172    let ay = if y < 0.0 { -y } else { y };
173    if ay >= 9_007_199_254_740_992.0 {
174        // |y| >= 2^53: all representable IEEE-754 f64 values are even integers.
175        return 2;
176    }
177    let t = trunc(ay);
178    if t != ay {
179        return 0;
180    }
181    let n = t as u64;
182    if (n & 1) == 1 { 1 } else { 2 }
183}
184
185#[inline]
186fn powi_small(mut base: f64, exp_val: i32) -> f64 {
187    let mut e = if exp_val < 0 {
188        base = 1.0 / base;
189        (-exp_val) as u32
190    } else {
191        exp_val as u32
192    };
193    let mut acc = 1.0;
194    while e != 0 {
195        if (e & 1) != 0 {
196            acc *= base;
197        }
198        e >>= 1;
199        if e != 0 {
200            base *= base;
201        }
202    }
203    acc
204}
205
206#[cold]
207#[inline(never)]
208fn powf_special(x: f64, y: f64) -> f64 {
209    if y == 0.0 || x == 1.0 {
210        return 1.0;
211    }
212    if x.is_nan() || y.is_nan() {
213        return f64::NAN;
214    }
215
216    if y.is_infinite() {
217        let ax = if x < 0.0 { -x } else { x };
218        if ax == 1.0 {
219            return 1.0;
220        }
221        return if (ax > 1.0) == (y > 0.0) {
222            f64::INFINITY
223        } else {
224            0.0
225        };
226    }
227
228    let y_int = classify_integer(y);
229
230    if x.is_infinite() {
231        if x > 0.0 {
232            return if y > 0.0 { f64::INFINITY } else { 0.0 };
233        }
234        return if y > 0.0 {
235            if y_int == 1 {
236                f64::NEG_INFINITY
237            } else {
238                f64::INFINITY
239            }
240        } else if y_int == 1 {
241            -0.0
242        } else {
243            0.0
244        };
245    }
246
247    if x == 0.0 {
248        let neg_zero = (x.to_bits() >> 63) != 0;
249        return if y > 0.0 {
250            if neg_zero && y_int == 1 { -0.0 } else { 0.0 }
251        } else if neg_zero && y_int == 1 {
252            f64::NEG_INFINITY
253        } else {
254            f64::INFINITY
255        };
256    }
257
258    let mut sign = 1.0;
259    let ax = if x < 0.0 {
260        if y_int == 0 {
261            return f64::NAN;
262        }
263        if y_int == 1 {
264            sign = -1.0;
265        }
266        -x
267    } else {
268        x
269    };
270
271    if y_int != 0 && (-64.0..=64.0).contains(&y) {
272        return sign * powi_small(ax, y as i32);
273    }
274
275    sign * exp(y * ln(ax))
276}
277
278/// Computes $x^y$ following IEEE-754 special-case rules.
279#[must_use]
280#[inline]
281pub fn powf(x: f64, y: f64) -> f64 {
282    let ux = x.to_bits();
283    let ay_bits = y.to_bits() & 0x7fff_ffff_ffff_ffff;
284    if ux.wrapping_sub(0x0010_0000_0000_0000) < 0x7fe0_0000_0000_0000
285        && ux != 0x3ff0_0000_0000_0000
286        && ay_bits.wrapping_sub(0x0010_0000_0000_0000) < 0x7fe0_0000_0000_0000
287    {
288        if ay_bits <= 0x4050_0000_0000_0000 {
289            let yi = y as i32;
290            if (yi as f64) == y {
291                return powi_small(x, yi);
292            }
293        }
294        return exp(y * ln_pos_normal(ux));
295    }
296    powf_special(x, y)
297}
298
299#[cfg(test)]
300mod tests {
301    use super::*;
302
303    fn rel_err(actual: f64, expected: f64) -> f64 {
304        let diff = if actual >= expected {
305            actual - expected
306        } else {
307            expected - actual
308        };
309        diff / (if expected >= 0.0 { expected } else { -expected })
310    }
311
312    #[test]
313    fn rounding_and_sqrt_exact_and_edge_cases() {
314        assert_eq!(floor(2.7), 2.0);
315        assert_eq!(floor(-2.7), -3.0);
316        assert_eq!(floor(3.0), 3.0);
317        assert_eq!(floor(-3.0), -3.0);
318        assert_eq!(floor(0.0).to_bits(), 0.0f64.to_bits());
319        assert_eq!(floor(-0.0).to_bits(), (-0.0f64).to_bits());
320        assert!(floor(f64::NAN).is_nan());
321        assert_eq!(floor(f64::INFINITY), f64::INFINITY);
322        assert_eq!(floor(f64::NEG_INFINITY), f64::NEG_INFINITY);
323
324        assert_eq!(ceil(2.3), 3.0);
325        assert_eq!(ceil(-2.3), -2.0);
326        assert_eq!(ceil(4.0), 4.0);
327        assert_eq!(ceil(-4.0), -4.0);
328        assert_eq!(ceil(-0.0).to_bits(), (-0.0f64).to_bits());
329        assert!(ceil(f64::NAN).is_nan());
330
331        assert_eq!(trunc(2.9), 2.0);
332        assert_eq!(trunc(-2.9), -2.0);
333        assert_eq!(trunc(-0.5).to_bits(), (-0.0f64).to_bits());
334        assert!(trunc(f64::NAN).is_nan());
335    }
336
337    #[test]
338    fn ln_exp_powf_accuracy_and_ieee_special_cases() {
339        assert_eq!(ln(1.0), 0.0);
340        assert_eq!(ln(0.0), f64::NEG_INFINITY);
341        assert_eq!(ln(-0.0), f64::NEG_INFINITY);
342        assert!(ln(-1.0).is_nan());
343        assert!(ln(f64::NAN).is_nan());
344        assert_eq!(ln(f64::INFINITY), f64::INFINITY);
345
346        assert!(rel_err(ln(core::f64::consts::E), 1.0) < 1e-15);
347        assert!(rel_err(ln(2.0), core::f64::consts::LN_2) < 1e-15);
348        assert!(rel_err(ln(10.0), core::f64::consts::LN_10) < 1e-15);
349        assert!(rel_err(ln(0.5), -core::f64::consts::LN_2) < 1e-15);
350
351        assert_eq!(exp(0.0), 1.0);
352        assert_eq!(exp(800.0), f64::INFINITY);
353        assert_eq!(exp(-800.0), 0.0);
354        assert!(exp(f64::NAN).is_nan());
355        assert!(rel_err(exp(1.0), core::f64::consts::E) < 1e-15);
356        assert!(rel_err(exp(core::f64::consts::LN_2 * 10.0), 1024.0) < 1e-14);
357
358        assert_eq!(powf(2.0, 10.0), 1024.0);
359        assert_eq!(powf(-2.0, 3.0), -8.0);
360        assert_eq!(powf(-2.0, 4.0), 16.0);
361        assert!(powf(-2.0, 0.5).is_nan());
362        assert_eq!(powf(f64::NAN, 0.0), 1.0);
363        assert_eq!(powf(1.0, f64::NAN), 1.0);
364        assert_eq!(powf(1.0, f64::INFINITY), 1.0);
365        assert_eq!(powf(-1.0, f64::INFINITY), 1.0);
366        assert_eq!(powf(0.0, 3.0).to_bits(), 0.0f64.to_bits());
367        assert_eq!(powf(-0.0, 3.0).to_bits(), (-0.0f64).to_bits());
368        assert_eq!(powf(-0.0, 4.0).to_bits(), 0.0f64.to_bits());
369        assert_eq!(powf(0.0, -2.0), f64::INFINITY);
370        assert_eq!(powf(-0.0, -3.0), f64::NEG_INFINITY);
371        assert!(rel_err(powf(9.0, 0.5), 3.0) < 1e-14);
372        assert!(rel_err(powf(core::f64::consts::E, 2.5), exp(2.5)) < 1e-14);
373    }
374}