Skip to main content

embedded_maths/embedded-maths-functions/
log2.rs

1//! log base 2 approché pour `f32`, sans dépendance externe.
2//!
3//! log2(x) = ln(x) · log2(e).
4//! Pour de meilleures performances et une meilleure précision, on exploite
5//! directement l'exposant : x = m · 2^e, donc log2(x) = e + log2(m).
6
7use super::ln; // `ln(x: f32) -> f32`, définie dans le module parent
8use core::f32::consts::LOG2_E;
9
10/// Approximation du logarithme en base 2 de `x`.
11///
12/// - `x < 0` ou NaN → NaN
13/// - `x == 0`       → -∞
14/// - `x == +∞`      → +∞
15pub fn log2(x: f32) -> f32 {
16    ln(x) * LOG2_E
17}
18
19#[cfg(test)]
20mod tests {
21    use super::log2;
22    use core::f32::consts::LOG2_10;
23
24    const MAX_REL_ERROR: f32 = 1e-5;
25
26    /// 10^k par multiplications successives (pas de `powi` en `no_std`).
27    fn pow10(k: i32) -> f32 {
28        let mut r = 1.0f32;
29        for _ in 0..k.abs() {
30            r *= 10.0;
31        }
32        if k < 0 { 1.0 / r } else { r }
33    }
34
35    #[test]
36    fn one_is_zero() {
37        assert_eq!(log2(1.0), 0.0);
38    }
39
40    #[test]
41    fn powers_of_ten() {
42        // log2(10^k) = k · log2(10), constante indépendante de notre `ln`.
43        for k in (-20..=19).filter(|&k| k != 0) {
44            let expected = k as f32 * LOG2_10;
45            let got = log2(pow10(k));
46            let rel = ((got - expected) / expected).abs();
47            assert!(
48                rel <= MAX_REL_ERROR,
49                "k={k}: {got} vs {expected} (rel {rel})"
50            );
51        }
52    }
53
54    #[test]
55    fn exact_powers_of_two() {
56        // 2^k construit exactement via les bits, k ∈ [-126, 127].
57        for k in -126..=127 {
58            let x = f32::from_bits(((k + 127) as u32) << 23);
59            let got = log2(x);
60            assert!((got - k as f32).abs() <= 1e-4, "k={k}: {got}");
61        }
62    }
63
64    #[test]
65    fn special_values() {
66        assert!(log2(-1.0).is_nan());
67        assert!(log2(f32::NAN).is_nan());
68        assert_eq!(log2(0.0), f32::NEG_INFINITY);
69        assert_eq!(log2(f32::INFINITY), f32::INFINITY);
70    }
71}