mazth 0.6.0

Matrix utilities.
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

#[allow(unused_imports)]
use std::cmp::Ordering;
#[allow(unused_imports)]
use std::ops::Div;

use std::f32::consts::PI;

use i_comparable::IComparableError;

use mat::Mat3x1;
use mat::Mat4;
use mat::Mat4x1;
use quat::Quat;

#[test]
fn test_quat() {
    {
        //convert axis angle to quaternion representation and back
        let axis = Mat3x1 {
            _val: [1f32, 2f32, 3f32],
        };
        let axis_normalize = axis.normalize().expect("normalize invalid");
        let q = Quat::<f32>::init_from_axis_angle_degree((axis, 90f32));
        let (axis, angle) = q.to_axis_angle();
        assert!(axis
            .is_equal(&axis_normalize, 0.0001f32)
            .expect("is_equal invalid"));
        assert!(angle / PI * 180f32 == 90f32);
    }
    {
        //compute rotation using quaternion
        //rotate a vector using the rotation matrix and compare to rotation using quaternions
        let p = Mat3x1 {
            _val: [1f32, 5f32, -3f32],
        };

        let axis = Mat3x1 {
            _val: [1f32, 0f32, 0f32],
        };
        let axis_normalize = axis.normalize().expect("normalize invalid");
        let q = Quat::<f32>::init_from_axis_angle_degree((axis, 90f32));
        let (axis, angle) = q.to_axis_angle();
        assert!(axis
            .is_equal(&axis_normalize, 0.0001f32)
            .expect("is_equal invalid"));
        assert!(angle / PI * 180f32 == 90f32);

        let row_major = true;
        let rot = q.to_rotation_matrix(row_major);

        assert!(rot
            .is_equal(
                &Mat4 {
                    _val: [
                        1f32, 0f32, 0f32, 0f32, 0f32, 0f32, -1f32, 0f32, 0f32, 1f32, 0f32, 0f32,
                        0f32, 0f32, 0f32, 1f32
                    ],
                    _is_row_major: true
                },
                0.0001f32
            )
            .expect("rotation matrix is_equal invalid"));

        let ans_1 = rot
            .mul_mat4x1(&Mat4x1 {
                _val: [p._val[0], p._val[1], p._val[2], 1f32],
            })
            .expect("rotation mul p invalid");
        let ans_2 = q.rotate_vector(p);
        assert!(ans_2
            .is_equal(
                &Mat3x1 {
                    _val: [ans_1._val[0], ans_1._val[1], ans_1._val[2]]
                },
                0.00001f32
            )
            .expect("rotations is_equal invalid"));
    }
}