lodestone_core 0.2.3

User friendly magnetic field calculations 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

use crate::points::Point2;

/// Rotates a 2D point `Point2` about an angle `alpha`
pub fn rotate_point2(point: &Point2, alpha: &f64) -> Point2 {
    let x_rot = point.x * alpha.cos() - point.y * alpha.sin();
    let y_rot = point.x * alpha.sin() + point.y * alpha.cos();
    Point2::new(x_rot, y_rot)
}

/// Rotates a 2D point tuple`(x,y)` about an angle `alpha`
pub fn rotate_tuple2(point: (&f64, &f64), alpha: &f64) -> (f64, f64) {
    let x_rot = point.0 * alpha.cos() - point.1 * alpha.sin();
    let y_rot = point.0 * alpha.sin() + point.1 * alpha.cos();
    (x_rot, y_rot)
}

#[cfg(test)]
mod tests {
    use super::{rotate_point2, rotate_tuple2, Point2};
    use crate::utils::comparison::nearly_equal;

    #[test]
    fn test_rotate_point2_90() {
        let point = Point2::new(1.0, 1.0);
        let rot_point = rotate_point2(&point, &90.0_f64.to_radians());
        assert!(nearly_equal(-1.0, rot_point.x));
        assert!(nearly_equal(1.0, rot_point.y));
    }

    #[test]
    fn test_rotate_point2_180() {
        let point = Point2::new(1.0, 1.0);
        let rot_point = rotate_point2(&point, &180.0_f64.to_radians());
        assert!(nearly_equal(-1.0, rot_point.x));
        assert!(nearly_equal(-1.0, rot_point.y));
    }

    #[test]
    fn test_rotate_point2_270() {
        let point = Point2::new(1.0, 1.0);
        let rot_point = rotate_point2(&point, &270.0_f64.to_radians());
        assert!(nearly_equal(1.0, rot_point.x));
        assert!(nearly_equal(-1.0, rot_point.y));
    }

    #[test]
    fn test_rotate_tuple2_90() {
        let point = (&1.0, &1.0);
        let rot_point = rotate_tuple2(point, &90.0_f64.to_radians());
        assert!(nearly_equal(-1.0, rot_point.0));
        assert!(nearly_equal(1.0, rot_point.1));
    }

    #[test]
    fn test_rotate_tuple2_180() {
        let point = (&1.0, &1.0);
        let rot_point = rotate_tuple2(point, &180.0_f64.to_radians());
        assert!(nearly_equal(-1.0, rot_point.0));
        assert!(nearly_equal(-1.0, rot_point.1));
    }

    #[test]
    fn test_rotate_tuple2_270() {
        let point = (&1.0, &1.0);
        let rot_point = rotate_tuple2(point, &270.0_f64.to_radians());
        assert!(nearly_equal(1.0, rot_point.0));
        assert!(nearly_equal(-1.0, rot_point.1));
    }

    #[test]
    fn test_rotate_tuple2_45_x_axis() {
        let point = (&1.0, &0.0);
        let rot_point = rotate_tuple2(point, &45.0_f64.to_radians());

        let rot_x = nearly_equal(1.0 / 2.0_f64.sqrt(), rot_point.0);
        let rot_y = nearly_equal(1.0 / 2.0_f64.sqrt(), rot_point.1);
        println!("Result: {:?}", rot_point);
        assert!(rot_x, "x false");
        assert!(rot_y, "y false");
    }

    #[test]
    fn test_rotate_tuple2_45_yaxis() {
        let point = (&0.0, &1.0);
        let alpha = -45.0_f64.to_radians();
        println!("Alpha : {}", alpha);
        let rot_point = rotate_tuple2(point, &alpha);

        let rot_x = nearly_equal(1.0 / 2.0_f64.sqrt(), rot_point.0);
        let rot_y = nearly_equal(1.0 / 2.0_f64.sqrt(), rot_point.1);
        println!("Result: {:?}", rot_point);
        assert!(rot_x, "x false");
        assert!(rot_y, "y false");
    }
}