rustebra 0.4.0

A hybrid no_std/alloc linear algebra crate for Rust, scaling from embedded targets to dynamic Krylov subspace solvers.
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use super::FloatTolerance;
use super::Scalar;
use super::newton_raphson::newton_raphson;
use super::trigonometry::{cos, reduce_f64, sin};

impl Scalar for f64 {
    fn zero() -> Self {
        0.0
    }

    fn one() -> Self {
        1.0
    }

    fn add(self, rhs: Self) -> Self {
        self + rhs
    }

    fn sub(self, rhs: Self) -> Self {
        self - rhs
    }

    fn mul(self, rhs: Self) -> Self {
        self * rhs
    }

    fn div(self, rhs: Self) -> Self {
        self / rhs
    }

    fn sqrt(self) -> Self {
        newton_raphson(self, 0.0, 2.0)
    }

    fn sin(self) -> Self {
        let (r, quadrant) = reduce_f64(self);
        match quadrant {
            0 => sin(r, Self::zero(), Self::one()),
            1 => cos(r, Self::zero(), Self::one()),
            2 => -sin(r, Self::zero(), Self::one()),
            _ => -cos(r, Self::zero(), Self::one()),
        }
    }

    fn cos(self) -> Self {
        let (r, quadrant) = reduce_f64(self);
        match quadrant {
            0 => cos(r, Self::zero(), Self::one()),
            1 => -sin(r, Self::zero(), Self::one()),
            2 => -cos(r, Self::zero(), Self::one()),
            _ => sin(r, Self::zero(), Self::one()),
        }
    }
}

impl FloatTolerance for f64 {
    fn epsilon() -> Self {
        f64::EPSILON
    }
}

#[cfg(test)]
mod tests {
    use super::{FloatTolerance, Scalar};

    #[test]
    fn identities() {
        assert_eq!(f64::zero(), 0.0);
        assert_eq!(f64::one(), 1.0);
    }

    #[test]
    fn arithmetic() {
        assert_eq!(2.0f64.add(3.0), 5.0);
        assert_eq!(5.0f64.sub(3.0), 2.0);
        assert_eq!(2.0f64.mul(3.0), 6.0);
        assert_eq!(6.0f64.div(3.0), 2.0);
    }

    #[test]
    fn sqrt_of_perfect_square_is_exact() {
        // Called via `Scalar::sqrt`, not `.sqrt()`: in `std` test builds, `f64` has its own
        // inherent `sqrt`, which would shadow the trait method `.sqrt()` resolves to.
        assert_eq!(Scalar::sqrt(4.0f64), 2.0);
        assert_eq!(Scalar::sqrt(0.0f64), 0.0);
    }

    #[test]
    fn sqrt_of_irrational_is_within_tolerance() {
        let result = Scalar::sqrt(2.0f64);
        let expected = core::f64::consts::SQRT_2;
        assert!((result - expected).abs() < 1e-9);
    }

    #[test]
    fn sqrt_of_negative_returns_zero() {
        assert_eq!(Scalar::sqrt(-4.0f64), 0.0);
    }

    #[test]
    fn sin_of_known_angles() {
        assert_eq!(Scalar::sin(0.0f64), 0.0);

        let result = Scalar::sin(core::f64::consts::FRAC_PI_2);
        assert!((result - 1.0).abs() < 1e-9);

        let result = Scalar::sin(core::f64::consts::PI);
        assert!((result - 0.0).abs() < 1e-9);
    }

    #[test]
    fn cos_of_known_angles() {
        assert_eq!(Scalar::cos(0.0f64), 1.0);

        let result = Scalar::cos(core::f64::consts::FRAC_PI_2);
        assert!((result - 0.0).abs() < 1e-9);

        let result = Scalar::cos(core::f64::consts::PI);
        assert!((result - (-1.0)).abs() < 1e-9);
    }

    #[test]
    fn epsilon_matches_core() {
        assert_eq!(f64::epsilon(), f64::EPSILON);
    }
}