aljabar 1.0.2

A super generic, super experimental linear algebra library.
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

//! Support for iterating over matrix rows. This is less natural than
//! iterating over columns due to the iteration not matching the stride
//! of the underlying storage.

use super::*;

/// A view into a given row of a matrix. It's possible to index just like a
/// normal Vector, but doesn't support the usual operators. It can only be
/// converted to a a Vector if the scalar value supports Clone.
pub struct RowView<'a, T, const N: usize, const M: usize> {
    row:    usize,
    matrix: &'a Matrix<T, { N }, { M }>,
}

impl<'a, T, const N: usize, const M: usize> RowView<'a, T, { N }, { M }> {
    /// Returns an iterator over the given row.
    pub fn iter(&self) -> impl Iterator<Item = &'a T> {
        RowViewIter {
            row:    self.row,
            col:    0,
            matrix: self.matrix,
        }
    }
}

impl<'a, T, const N: usize, const M: usize> IntoIterator for RowView<'a, T, { N }, { M }> {
    type Item = &'a T;
    type IntoIter = RowViewIter<'a, T, { N }, { M }>;

    fn into_iter(self) -> Self::IntoIter {
        RowViewIter {
            row:    self.row,
            col:    0,
            matrix: self.matrix,
        }
    }
}

impl<'a, T, const N: usize, const M: usize> Index<usize> for RowView<'a, T, { N }, { M }> {
    type Output = T;

    fn index(&self, column: usize) -> &Self::Output {
        &self.matrix[column][self.row]
    }
}

/// An iterator over a [RowView].
pub struct RowViewIter<'a, T, const N: usize, const M: usize> {
    row:    usize,
    col:    usize,
    matrix: &'a Matrix<T, { N }, { M }>,
}

impl<'a, T, const N: usize, const M: usize> Iterator for RowViewIter<'a, T, { N }, { M }> {
    type Item = &'a T;

    fn next(&mut self) -> Option<Self::Item> {
        let col = if self.col < M {
            self.col
        } else {
            return None;
        };
        self.col += 1;
        Some(&self.matrix[col][self.row])
    }
}

pub(super) struct RowIter<'a, T, const N: usize, const M: usize> {
    pub(super) row:    usize,
    pub(super) matrix: &'a Matrix<T, { N }, { M }>,
}

impl<'a, T, const N: usize, const M: usize> Iterator for RowIter<'a, T, { N }, { M }> {
    type Item = RowView<'a, T, { N }, { M }>;

    fn next(&mut self) -> Option<Self::Item> {
        let row = if self.row < N {
            Some(RowView {
                row:    self.row,
                matrix: self.matrix,
            })
        } else {
            None
        };
        self.row += 1;
        row
    }
}

/// A mutable view into a given row of a matrix. It's possible to index just
/// like a normal Vector, but doesn't support the usual operators. It can only
/// be converted to a Vector if the scalar value supports Clone.
pub struct RowViewMut<'a, T, const N: usize, const M: usize> {
    pub(super) row:    usize,
    pub(super) matrix: &'a mut Matrix<T, { N }, { M }>,
}

impl<'a, T, const N: usize, const M: usize> Index<usize> for RowViewMut<'a, T, { N }, { M }> {
    type Output = T;

    fn index(&self, column: usize) -> &Self::Output {
        &self.matrix[column][self.row]
    }
}

impl<'a, T, const N: usize, const M: usize> IndexMut<usize> for RowViewMut<'a, T, { N }, { M }> {
    fn index_mut(&mut self, column: usize) -> &mut Self::Output {
        &mut self.matrix[column][self.row]
    }
}

pub(super) struct RowIterMut<'a, T, const N: usize, const M: usize> {
    pub(super) row:     usize,
    pub(super) matrix:  *mut Matrix<T, { N }, { M }>,
    pub(super) phantom: PhantomData<&'a mut Matrix<T, { N }, { M }>>,
}

impl<'a, T, const N: usize, const M: usize> Iterator for RowIterMut<'a, T, { N }, { M }> {
    type Item = RowViewMut<'a, T, { N }, { M }>;

    fn next(&mut self) -> Option<Self::Item> {
        let row = if self.row < N {
            Some(RowViewMut {
                row:    self.row,
                matrix: unsafe { &mut *self.matrix },
            })
        } else {
            None
        };
        self.row += 1;
        row
    }
}