use-math-constants 0.1.0

Reusable mathematical constants for RustUse
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

#![forbid(unsafe_code)]

//! Reusable mathematical constants expressed as plain `f64` values.

/// Mathematical constant $\pi$, dimensionless.
pub const PI: f64 = std::f64::consts::PI;

/// Mathematical constant $\tau = 2\pi$, dimensionless.
pub const TAU: f64 = std::f64::consts::TAU;

/// Mathematical constant $e$, dimensionless.
pub const E: f64 = std::f64::consts::E;

/// Approximate mathematical constant $\varphi$, the golden ratio, dimensionless.
pub const PHI: f64 = 1.618_033_988_749_895_f64;

/// Mathematical constant $\sqrt{2}$, dimensionless.
pub const SQRT_2: f64 = std::f64::consts::SQRT_2;

/// Approximate mathematical constant $\sqrt{3}$, dimensionless.
pub const SQRT_3: f64 = 1.732_050_807_568_877_2_f64;

/// Mathematical constant $\ln(2)$, dimensionless.
pub const LN_2: f64 = std::f64::consts::LN_2;

/// Mathematical constant $\ln(10)$, dimensionless.
pub const LN_10: f64 = std::f64::consts::LN_10;

/// Mathematical constant $\log_2(e)$, dimensionless.
pub const LOG2_E: f64 = std::f64::consts::LOG2_E;

/// Mathematical constant $\log_{10}(e)$, dimensionless.
pub const LOG10_E: f64 = std::f64::consts::LOG10_E;

/// Mathematical constant $1 / \pi$, dimensionless.
pub const FRAC_1_PI: f64 = std::f64::consts::FRAC_1_PI;

/// Mathematical constant $2 / \pi$, dimensionless.
pub const FRAC_2_PI: f64 = std::f64::consts::FRAC_2_PI;

/// Mathematical constant $\pi / 2$, dimensionless.
pub const FRAC_PI_2: f64 = std::f64::consts::FRAC_PI_2;

/// Mathematical constant $\pi / 3$, dimensionless.
pub const FRAC_PI_3: f64 = std::f64::consts::FRAC_PI_3;

/// Mathematical constant $\pi / 4$, dimensionless.
pub const FRAC_PI_4: f64 = std::f64::consts::FRAC_PI_4;

/// Mathematical constant $\pi / 6$, dimensionless.
pub const FRAC_PI_6: f64 = std::f64::consts::FRAC_PI_6;

/// Mathematical constant $\pi / 8$, dimensionless.
pub const FRAC_PI_8: f64 = std::f64::consts::FRAC_PI_8;

#[cfg(test)]
mod tests {
    use super::{FRAC_PI_4, PHI, PI, TAU};

    fn approx_eq(left: f64, right: f64, relative_tolerance: f64) {
        let scale = left.abs().max(right.abs()).max(1.0);
        let delta = (left - right).abs();

        assert!(
            delta <= relative_tolerance * scale,
            "left={left:e} right={right:e} delta={delta:e} rel_tol={relative_tolerance:e}"
        );
    }

    #[test]
    fn tau_matches_twice_pi() {
        assert_eq!(TAU, 2.0 * PI);
    }

    #[test]
    fn phi_matches_its_defining_quadratic() {
        approx_eq(PHI * PHI, PHI + 1.0, 1.0e-12);
    }

    #[test]
    fn quarter_turns_reconstruct_pi() {
        assert_eq!(FRAC_PI_4 * 4.0, PI);
    }
}