numeris/dynmatrix/
slice.rs

1use super::DynMatrix;
2
3impl<T> DynMatrix<T> {
4    /// View the entire matrix as a flat slice in row-major order.
5    ///
6    /// ```
7    /// use numeris::DynMatrix;
8    /// let m = DynMatrix::from_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);
9    /// assert_eq!(m.as_slice(), &[1.0, 2.0, 3.0, 4.0]);
10    /// ```
11    #[inline]
12    pub fn as_slice(&self) -> &[T] {
13        &self.data
14    }
15
16    /// View the entire matrix as a mutable flat slice.
17    #[inline]
18    pub fn as_mut_slice(&mut self) -> &mut [T] {
19        &mut self.data
20    }
21
22    /// View row `i` as a slice.
23    ///
24    /// ```
25    /// use numeris::DynMatrix;
26    /// let m = DynMatrix::from_slice(2, 3, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
27    /// assert_eq!(m.row_slice(0), &[1.0, 2.0, 3.0]);
28    /// assert_eq!(m.row_slice(1), &[4.0, 5.0, 6.0]);
29    /// ```
30    #[inline]
31    pub fn row_slice(&self, i: usize) -> &[T] {
32        let start = i * self.ncols;
33        &self.data[start..start + self.ncols]
34    }
35
36    /// View row `i` as a mutable slice.
37    #[inline]
38    pub fn row_slice_mut(&mut self, i: usize) -> &mut [T] {
39        let start = i * self.ncols;
40        let end = start + self.ncols;
41        &mut self.data[start..end]
42    }
43
44    /// Iterate over all elements in row-major order.
45    #[inline]
46    pub fn iter(&self) -> core::slice::Iter<'_, T> {
47        self.data.iter()
48    }
49
50    /// Iterate mutably over all elements in row-major order.
51    #[inline]
52    pub fn iter_mut(&mut self) -> core::slice::IterMut<'_, T> {
53        self.data.iter_mut()
54    }
55}
56
57impl<'a, T> IntoIterator for &'a DynMatrix<T> {
58    type Item = &'a T;
59    type IntoIter = core::slice::Iter<'a, T>;
60
61    #[inline]
62    fn into_iter(self) -> Self::IntoIter {
63        self.iter()
64    }
65}
66
67impl<'a, T> IntoIterator for &'a mut DynMatrix<T> {
68    type Item = &'a mut T;
69    type IntoIter = core::slice::IterMut<'a, T>;
70
71    #[inline]
72    fn into_iter(self) -> Self::IntoIter {
73        self.iter_mut()
74    }
75}
76
77#[cfg(test)]
78mod tests {
79    use super::*;
80
81    #[test]
82    fn as_slice() {
83        let m = DynMatrix::from_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);
84        assert_eq!(m.as_slice(), &[1.0, 2.0, 3.0, 4.0]);
85    }
86
87    #[test]
88    fn as_mut_slice() {
89        let mut m = DynMatrix::from_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);
90        m.as_mut_slice()[0] = 99.0;
91        assert_eq!(m[(0, 0)], 99.0);
92    }
93
94    #[test]
95    fn row_slice() {
96        let m = DynMatrix::from_slice(2, 3, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
97        assert_eq!(m.row_slice(0), &[1.0, 2.0, 3.0]);
98        assert_eq!(m.row_slice(1), &[4.0, 5.0, 6.0]);
99    }
100
101    #[test]
102    fn iter() {
103        let m = DynMatrix::from_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);
104        let sum: f64 = m.iter().sum();
105        assert_eq!(sum, 10.0);
106    }
107
108    #[test]
109    fn iter_mut() {
110        let mut m = DynMatrix::from_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);
111        for x in m.iter_mut() {
112            *x *= 2.0;
113        }
114        assert_eq!(m[(0, 0)], 2.0);
115        assert_eq!(m[(1, 1)], 8.0);
116    }
117
118    #[test]
119    fn into_iter_ref() {
120        let m = DynMatrix::from_slice(2, 2, &[1.0, 2.0, 3.0, 4.0]);
121        let sum: f64 = (&m).into_iter().sum();
122        assert_eq!(sum, 10.0);
123    }
124
125    #[test]
126    fn into_iter_for_loop() {
127        let m = DynMatrix::from_slice(2, 2, &[1, 2, 3, 4]);
128        let mut sum = 0;
129        for &x in &m {
130            sum += x;
131        }
132        assert_eq!(sum, 10);
133    }
134}
numeris/dynmatrix/slice.rs

numeris/dynmatrix/
slice.rs
