trig-const 0.4.0

Const trig functions in Rust
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use core::f64::consts::PI;

use trig_const::{acos, acosh, asin, asinh, atan, atan2, cos, ln, pow, sin, sqrt, tan};

fn float_loop(start: f64, stop: f64, step: f64) -> impl Iterator<Item = f64> {
    core::iter::successors(Some(start), move |prev| {
        let next = prev + step;
        (next < stop).then_some(next)
    })
}

macro_rules! float_eq {
    ($lhs:expr, $rhs:expr, $tol:expr) => {
        if !$lhs.is_nan() && !$rhs.is_nan() {
            assert!(($lhs - $rhs).abs() < $tol, "lhs: {}, rhs: {}", $lhs, $rhs);
        }
    };
    ($lhs:expr, $rhs:expr) => {
        float_eq!($lhs, $rhs, 10e-12);
    };
}

#[test]
fn test_sin() {
    for x in float_loop(-8.0 * PI, 8.0 * PI, 0.01) {
        float_eq!(sin(x), x.sin());
    }
}

#[test]
fn test_cos() {
    for x in float_loop(-8.0 * PI, 8.0 * PI, 0.01) {
        float_eq!(cos(x), x.cos());
    }
}

#[test]
fn test_tan() {
    for x in float_loop(-8.0 * PI, 8.0 * PI, 0.01) {
        float_eq!(tan(x), x.tan());
    }
}

#[test]
fn test_asin() {
    for x in float_loop(-1.0, 1.0, 0.01) {
        float_eq!(asin(x), x.asin());
    }
}

#[test]
fn test_acos() {
    for x in float_loop(-1.0, 1.0, 0.01) {
        float_eq!(acos(x), x.acos());
    }
}

#[test]
fn test_atan() {
    for x in float_loop(-2.0 * PI, 2.0 * PI, 0.01) {
        float_eq!(atan(x), x.atan());
    }
}

#[test]
fn test_atan2() {
    for x in float_loop(-2.0 * PI, 2.0 * PI, 0.01) {
        for y in float_loop(-2.0 * PI, 2.0 * PI, 0.01) {
            float_eq!(atan2(x, y), x.atan2(y));
        }
    }
}

#[test]
fn test_asinh() {
    for x in float_loop(0.0, 1.0, 0.01) {
        float_eq!(asinh(x), x.asinh());
    }
}

#[test]
fn test_acosh() {
    for x in float_loop(0.0, 1.0, 0.01) {
        float_eq!(acosh(x), x.acosh());
    }
}

#[test]
fn test_ln() {
    for x in float_loop(1.0, 10.0, 0.01) {
        float_eq!(ln(x), x.ln());
    }
}

#[test]
fn test_sqrt() {
    for x in float_loop(0.0, 10.0, 0.01) {
        float_eq!(sqrt(x), x.sqrt());
    }
}

#[test]
fn test_pow() {
    for x in float_loop(-10.0, 10.0, 1.0) {
        for y in float_loop(-2.0, 3.0, 0.5) {
            if x != 0.0 {
                float_eq!(pow(x, y), x.powf(y));
            }
        }
    }
}