Skip to main content

embedded_maths/embedded-maths-functions/
log.rs

1//! log_b(x) approché pour `f32`, sans dépendance externe.
2//!
3//! Formule du changement de base : log_b(x) = ln(x) / ln(b).
4
5use super::ln; // `ln(x: f32) -> f32`, définie dans le module parent
6
7/// Approximation du logarithme de `x` dans la base `base`.
8///
9/// - `x < 0`, `base < 0` ou NaN → NaN
10/// - `base == 1`               → ±∞, ou NaN si x == 1
11/// - `x == 0`                  → -∞ si base > 1, +∞ si 0 < base < 1
12pub fn log(x: f32, base: f32) -> f32 {
13    ln(x) / ln(base)
14}
15
16#[cfg(test)]
17mod tests {
18    use super::log;
19    use core::f32::consts::LN_10;
20
21    const MAX_REL_ERROR: f32 = 1e-5;
22
23    // Valeurs de référence indépendantes de notre `ln`.
24    const LN_3: f32 = 1.098_612_3;
25    const LN_5_5: f32 = 1.704_748_1;
26    const LN_12_7: f32 = 2.541_602;
27
28    /// 10^k par multiplications successives (pas de `powi` en `no_std`).
29    fn pow10(k: i32) -> f32 {
30        let mut r = 1.0f32;
31        for _ in 0..k.abs() {
32            r *= 10.0;
33        }
34        if k < 0 { 1.0 / r } else { r }
35    }
36
37    /// Vérifie log_base(10^k) = k · ln(10) / ln(base) pour k ∈ [-20, 19].
38    fn check_powers_of_ten(base: f32, ln_base: f32) {
39        for k in (-20..=19).filter(|&k| k != 0) {
40            let expected = k as f32 * LN_10 / ln_base;
41            let got = log(pow10(k), base);
42            let rel = ((got - expected) / expected).abs();
43            assert!(
44                rel <= MAX_REL_ERROR,
45                "base={base}, k={k}: {got} vs {expected} (rel {rel})"
46            );
47        }
48    }
49
50    #[test]
51    fn one_is_zero() {
52        for base in [3.0, 5.5, 12.7] {
53            assert_eq!(log(1.0, base), 0.0);
54        }
55    }
56
57    #[test]
58    fn base_3() {
59        check_powers_of_ten(3.0, LN_3);
60    }
61
62    #[test]
63    fn base_5_5() {
64        check_powers_of_ten(5.5, LN_5_5);
65    }
66
67    #[test]
68    fn base_12_7() {
69        check_powers_of_ten(12.7, LN_12_7);
70    }
71
72    #[test]
73    fn exact_powers_of_two() {
74        // log_2(2^k) = k, avec 2^k construit exactement via les bits.
75        for k in -100..=100 {
76            let x = f32::from_bits(((k + 127) as u32) << 23);
77            let got = log(x, 2.0);
78            assert!((got - k as f32).abs() <= 1e-4, "k={k}: {got}");
79        }
80    }
81
82    #[test]
83    fn special_values() {
84        assert!(log(-1.0, 3.0).is_nan());
85        assert!(log(3.0, -1.0).is_nan());
86        assert!(log(f32::NAN, 3.0).is_nan());
87        assert_eq!(log(0.0, 3.0), f32::NEG_INFINITY);
88        assert_eq!(log(0.0, 0.5), f32::INFINITY);
89        assert!(log(5.0, 1.0).is_infinite());
90        assert!(log(1.0, 1.0).is_nan());
91    }
92}