matreex 0.44.5

A simple matrix implementation.
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

use super::Matrix;
use super::order::Order;
use crate::index::Index;

impl<L, LO, R, RO> PartialEq<Matrix<R, RO>> for Matrix<L, LO>
where
    L: PartialEq<R>,
    LO: Order,
    RO: Order,
{
    fn eq(&self, other: &Matrix<R, RO>) -> bool {
        if self.shape() != other.shape() {
            false
        } else if LO::KIND == RO::KIND {
            self.data == other.data
        } else {
            let lhs_stride = self.stride();
            let rhs_stride = other.stride();
            self.data.iter().enumerate().all(|(index, lhs)| {
                let index = Index::from_linear::<LO>(index, lhs_stride).to_linear::<RO>(rhs_stride);
                let rhs = unsafe { other.data.get_unchecked(index) };
                lhs == rhs
            })
        }
    }
}

impl<T, O> Eq for Matrix<T, O>
where
    T: PartialEq,
    O: Order,
{
}

#[cfg(test)]
mod tests {
    use super::super::layout::Layout;
    use super::super::order::{ColMajor, RowMajor};
    use super::*;
    use crate::shape::Shape;
    use crate::testkit::{MockL, MockR};
    use alloc::vec;

    #[test]
    fn test_eq() {
        let lhs: Matrix<MockL<i32>, RowMajor> = {
            let shape = Shape::new(2, 3);
            let layout = Layout::from_shape_unchecked(shape);
            let data = vec![MockL(1), MockL(2), MockL(3), MockL(4), MockL(5), MockL(6)];
            Matrix { layout, data }
        };
        let rhs: Matrix<MockR<i32>, RowMajor> = {
            let shape = Shape::new(2, 3);
            let layout = Layout::from_shape_unchecked(shape);
            let data = vec![MockR(1), MockR(2), MockR(3), MockR(4), MockR(5), MockR(6)];
            Matrix { layout, data }
        };
        assert_eq!(lhs, rhs);

        let lhs: Matrix<MockL<i32>, RowMajor> = {
            let shape = Shape::new(2, 3);
            let layout = Layout::from_shape_unchecked(shape);
            let data = vec![MockL(1), MockL(2), MockL(3), MockL(4), MockL(5), MockL(6)];
            Matrix { layout, data }
        };
        let rhs: Matrix<MockR<i32>, ColMajor> = {
            let shape = Shape::new(2, 3);
            let layout = Layout::from_shape_unchecked(shape);
            let data = vec![MockR(1), MockR(4), MockR(2), MockR(5), MockR(3), MockR(6)];
            Matrix { layout, data }
        };
        assert_eq!(lhs, rhs);

        let lhs: Matrix<MockL<i32>, ColMajor> = {
            let shape = Shape::new(2, 3);
            let layout = Layout::from_shape_unchecked(shape);
            let data = vec![MockL(1), MockL(4), MockL(2), MockL(5), MockL(3), MockL(6)];
            Matrix { layout, data }
        };
        let rhs: Matrix<MockR<i32>, RowMajor> = {
            let shape = Shape::new(2, 3);
            let layout = Layout::from_shape_unchecked(shape);
            let data = vec![MockR(1), MockR(2), MockR(3), MockR(4), MockR(5), MockR(6)];
            Matrix { layout, data }
        };
        assert_eq!(lhs, rhs);

        let lhs: Matrix<MockL<i32>, ColMajor> = {
            let shape = Shape::new(2, 3);
            let layout = Layout::from_shape_unchecked(shape);
            let data = vec![MockL(1), MockL(4), MockL(2), MockL(5), MockL(3), MockL(6)];
            Matrix { layout, data }
        };
        let rhs: Matrix<MockR<i32>, ColMajor> = {
            let shape = Shape::new(2, 3);
            let layout = Layout::from_shape_unchecked(shape);
            let data = vec![MockR(1), MockR(4), MockR(2), MockR(5), MockR(3), MockR(6)];
            Matrix { layout, data }
        };
        assert_eq!(lhs, rhs);
    }
}