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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

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

use i_comparable::IComparableError;

#[test]
fn test_mat1x3() {
    use mat::Mat1x3;
    use mat::Mat3;
    {
        let v = Mat1x3 { _val: [10f64; 3] };
        assert!(v.size().expect("size result invalid") == 3);

        let v2 = Mat1x3 { _val: [2f64; 3] };

        {
            let v3 = v.mul_elem(&v2).expect("mul result invalid");
            assert!(v3
                .is_equal(&Mat1x3 { _val: [20f64; 3] }, 0.0001f64)
                .expect("Mat1x3 is_equal invalid"));
        }
        {
            let v3 = v.div(&v2).expect("div result invalid");
            assert!(v3
                .is_equal(&Mat1x3 { _val: [5f64; 3] }, 0.0001f64)
                .expect("Mat1x3 is_equal invalid"));
        }
        {
            let v3 = v.plus(&v2).expect("plus result invalid");
            assert!(v3
                .is_equal(&Mat1x3 { _val: [12f64; 3] }, 0.0001f64)
                .expect("Mat1x3 is_equal invalid"));
        }
        {
            let v3 = v.minus(&v2).expect("plus result invalid");
            assert!(v3
                .is_equal(&Mat1x3 { _val: [8f64; 3] }, 0.0001f64)
                .expect("Mat1x3 is_equal invalid"));
        }

        assert!(v2.magnitude().expect("magnitude invalid") == ((2f64 * 2f64) * 3f64).sqrt());

        let v4 = v2.normalize().expect("normalize invalid");
        assert!(v4
            .is_equal(
                &Mat1x3 {
                    _val: [2f64.div((2f64 * 2f64 * 3f64).sqrt()); 3]
                },
                0.0001f64
            )
            .expect("Mat1x3 is_equal invalid"));

        let v5 = v2.scale(4f64).expect("scale invalid");
        assert!(v5
            .is_equal(&Mat1x3 { _val: [8f64; 3] }, 0.0001f64)
            .expect("Mat1x3 is_equal invalid"));

        let v6 = Mat1x3 {
            _val: [5.0f64, 5.3f64, 7.7f64],
        };
        let v7 = Mat1x3 {
            _val: [5.1f64, 5.4f64, 7.8f64],
        };
        assert!(v6
            .is_equal(&v7, 0.1001f64)
            .expect("Mat1x3 is_equal invalid"));
        assert!(
            v6.is_equal(&v7, 0.0999f64)
                .expect("Mat1x3 is_equal invalid")
                == false
        );
    }
    {
        //mat1x3 mul mat3x3
        let v2 = Mat1x3 {
            _val: [1f64, 2f64, -4f64],
        };
        let mut arr = [0f64; 9];
        for x in 0..9 {
            arr[x] = x as f64;
        }
        let is_row_major = true;
        let v1 = Mat3::<f64>::init(arr, is_row_major);
        let v3 = v2.mul_mat3x3(&v1).expect("mat1x3 mul mat3x3 invalid");
        assert!(v3
            .is_equal(
                &Mat1x3 {
                    _val: [-18f64, -19f64, -20f64]
                },
                0.00001f64
            )
            .expect("mat1x4 is_equal invalid"));
    }
}