vqm 0.1.9

A vector, quaternion, and matrix library targeted at embedded systems and robotics.
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use num_traits::identities::{One, Zero};
use vqm::{Matrix2x2, Matrix2x2f32, Vector2d};

// **** Align

const _: () = assert!(core::mem::size_of::<Matrix2x2<f32>>() == 16);
const _: () = assert!(core::mem::align_of::<Matrix2x2<f32>>() == 16);

const _: () = assert!(core::mem::size_of::<Matrix2x2<f64>>() == 32);
const _: () = assert!(core::mem::align_of::<Matrix2x2<f64>>() == 16);
#[cfg(test)]
mod tests {
    use super::*;
    #[cfg(feature = "serde")]
    use serde::{Deserialize, Serialize};

    fn _is_normal<T: Sized + Send + Sync + Unpin>() {}
    fn is_full<T: Sized + Send + Sync + Unpin + Copy + Clone + Default + PartialEq>() {}
    #[cfg(feature = "serde")]
    fn is_config<
        T: Sized + Send + Sync + Unpin + Copy + Clone + Default + PartialEq + Serialize + for<'a> Deserialize<'a>,
    >() {
    }

    #[test]
    fn normal_types() {
        is_full::<Matrix2x2<f32>>();
        #[cfg(feature = "serde")]
        is_config::<Matrix2x2<f32>>();
    }
    #[test]
    fn default() {
        let a: Matrix2x2<f32> = Matrix2x2f32::default();
        assert_eq!(a, Matrix2x2f32::from([0.0, 0.0, 0.0, 0.0]));
        let z = Matrix2x2f32::zero();
        //let z: Matrix2x2 = zero();
        assert_eq!(a, z);
        assert!(z.is_zero());
        assert!(!z.is_one());
        assert!(z.is_near_zero());

        let i = Matrix2x2f32::one();
        //let i: Matrix2x2 = one();
        assert!(i.is_one());
        assert!(!i.is_zero());
        assert!(i.is_near_identity());
    }
    #[test]
    fn neg() {
        let a = Matrix2x2f32::from([2.0, 3.0, 5.0, 7.0]);
        assert_eq!(-a, Matrix2x2f32::from([-2.0, -3.0, -5.0, -7.0]));

        let b = -a;
        assert_eq!(b, Matrix2x2f32::from([-2.0, -3.0, -5.0, -7.0]));
    }
    #[test]
    fn add() {
        let a = Matrix2x2f32::from([2.0, 3.0, 5.0, 7.0]);
        let b = Matrix2x2f32::from([29.0, 31.0, 37.0, 41.0]);
        let a_plus_b = Matrix2x2f32::from([2.0 + 29.0, 3.0 + 31.0, 5.0 + 37.0, 7.0 + 41.0]);
        assert_eq!(a + b, a_plus_b);
    }
    #[test]
    fn sub() {
        let a = Matrix2x2f32::from([2.0, 3.0, 5.0, 7.0]);
        let b = Matrix2x2f32::from([29.0, 31.0, 37.0, 41.0]);
        let a_minus_b = Matrix2x2::from([2.0 - 29.0, 3.0 - 31.0, 5.0 - 37.0, 7.0 - 41.0]);
        assert_eq!(a - b, a_minus_b);
    }
    #[test]
    fn mul() {
        let a = Matrix2x2f32::from([2.0, 3.0, 5.0, 7.0]);
        let b = Matrix2x2f32::from([29.0, 31.0, 37.0, 41.0]);
        let a_times_b = Matrix2x2::from([
            2.0 * 29.0 + 3.0 * 37.0,
            2.0 * 31.0 + 3.0 * 41.0,
            5.0 * 29.0 + 7.0 * 37.0,
            5.0 * 31.0 + 7.0 * 41.0,
        ]);

        assert_eq!(a * b, a_times_b);
    }
    #[test]
    fn new() {
        let a = Matrix2x2::from([2.0, 3.0, 5.0, 7.0]);
        assert_eq!(a, a);
        let b = Matrix2x2::from([Vector2d { x: 2.0, y: 3.0 }, Vector2d { x: 5.0, y: 7.0 }]);
        assert_eq!(a, b);
        let c = Matrix2x2::from((Vector2d { x: 2.0, y: 3.0 }, Vector2d { x: 5.0, y: 7.0 }));
        assert_eq!(a, c);
        let d: Matrix2x2<f32> = Matrix2x2::new([2.0, 3.0, 5.0, 7.0]);
        assert_eq!(a, d);
    }
    #[test]
    fn from_array() {
        let a = Matrix2x2::from([2.0, 3.0, 5.0, 7.0]);
        assert_eq!(2.0, a[0]);
        assert_eq!(3.0, a[1]);
        assert_eq!(5.0, a[2]);
        assert_eq!(7.0, a[3]);
    }
    #[test]
    fn transpose() {
        let mut m: Matrix2x2<f32> = Matrix2x2::from([2.0, 3.0, 5.0, 7.0]);
        m.transpose_in_place();
        assert_eq!(Matrix2x2::from([2.0, 5.0, 3.0, 7.0]), m);
        m.transpose_in_place();
        assert_eq!(Matrix2x2::from([2.0, 3.0, 5.0, 7.0]), m);
        m.transpose_in_place().transpose_in_place();
        assert_eq!(Matrix2x2::from([2.0, 3.0, 5.0, 7.0]), m);
        let n = m.transpose();
        assert_eq!(Matrix2x2::from([2.0, 5.0, 3.0, 7.0]), n);
        let p = n.transpose();
        assert_eq!(m, p);
    }
    #[test]
    fn adjugate() {
        let a: Matrix2x2<f32> = Matrix2x2::from([2.0, 3.0, 5.0, 7.0]);
        let b = a.adjugate();
        let c = a * b;
        let determinant = a.determinant();
        assert!((c / determinant).is_near_identity());
    }
    #[test]
    fn inverse() {
        let a: Matrix2x2<f32> = Matrix2x2::from([2.0, 3.0, 5.0, 7.0]);
        let b = a.inverse();
        let c = a * b;
        assert_eq!(1.0, c[0]);
        assert_eq!(0.0, c[1]);
        assert_eq!(0.0, c[2]);
        assert_eq!(1.0, c[3]);
        //assert!((c[0] - 1.0).abs() < f32::EPSILON*3.0);
        //assert!((c[3] - 1.0).abs() < f32::EPSILON * 3.0);
        //assert!(c[1].abs() < f32::EPSILON);
        //assert!(c[2].abs() < f32::EPSILON);

        //assert!(((c - Matrix2x2::one()) / 5.0).is_near_zero());
    }
}