Add non trivial elements iterator

Author: maxtremblay

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sparse-bin-mat"
-version = "0.4.2"
+version = "0.4.3"
 authors = ["maxtremblay <maxtremblay>"]
 edition = "2018"
 description = "A sparse implementation of a binary matrix optimized for row operations"

src/matrix/mod.rs

@@ -313,6 +313,30 @@ impl SparseBinMat {
         Rows::from(self)
     }
 
+    /// Returns an iterator yielding the positions of the non
+    /// trivial elements.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use sparse_bin_mat::{SparseBinSlice, SparseBinMat};
+    /// let rows = vec![vec![0, 2], vec![1], vec![0, 2], vec![1]];
+    /// let matrix = SparseBinMat::new(3, rows);
+    ///
+    /// let mut iter = matrix.non_trivial_elements();
+    ///
+    /// assert_eq!(iter.next(), Some((0, 0)));
+    /// assert_eq!(iter.next(), Some((0, 2)));
+    /// assert_eq!(iter.next(), Some((1, 1)));
+    /// assert_eq!(iter.next(), Some((2, 0)));
+    /// assert_eq!(iter.next(), Some((2, 2)));
+    /// assert_eq!(iter.next(), Some((3, 1)));
+    /// assert_eq!(iter.next(), None);
+    /// ```
+    pub fn non_trivial_elements(&self) -> NonTrivialElements {
+        NonTrivialElements::new(self)
+    }
+
     /// Returns an iterator yielding the number
     /// of non zero elements in each row of the matrix.
     ///

src/matrix/non_trivial_elements.rs

@@ -1,27 +1,82 @@
 use super::SparseBinMat;
-use crate::SparseBinSlice;
 
 /// An iterator over the coordinates of non trivial elements.
 ///
 /// See the [`non_trivial_elements`](SparseBinMat::non_trivial_elements) method.
 #[derive(Debug, Clone)]
-pub struct NonTrivialElements<'a> {}
+pub struct NonTrivialElements<'a> {
+    matrix: &'a SparseBinMat,
+    row_index: usize,
+    column_index: usize,
+}
 
 impl<'a> NonTrivialElements<'a> {
-    pub(super) fn new(matrix: &'a SparseBinMat) -> Self {}
+    pub(super) fn new(matrix: &'a SparseBinMat) -> Self {
+        Self {
+            matrix,
+            row_index: 0,
+            column_index: 0,
+        }
+    }
+
+    fn next_element(&mut self) -> Option<(usize, usize)> {
+        self.matrix
+            .row(self.row_index)
+            .and_then(|row| row.as_slice().get(self.column_index).cloned())
+            .map(|column| (self.row_index, column))
+    }
 
     fn move_to_next_row(&mut self) {
-        todo!()
+        self.row_index += 1;
+        self.column_index = 0;
+    }
+
+    fn move_to_next_column(&mut self) {
+        self.column_index += 1;
+    }
+
+    fn is_done(&self) -> bool {
+        self.row_index >= self.matrix.number_of_rows()
     }
 }
 
 impl<'a> Iterator for NonTrivialElements<'a> {
     type Item = (usize, usize);
 
-    fn next(&mut self) -> Option<Self::Item> {}
+    fn next(&mut self) -> Option<Self::Item> {
+        println!("({}, {})", self.row_index, self.column_index);
+        if self.is_done() {
+            None
+        } else {
+            match self.next_element() {
+                Some(element) => {
+                    self.move_to_next_column();
+                    Some(element)
+                }
+                None => {
+                    self.move_to_next_row();
+                    self.next()
+                }
+            }
+        }
+    }
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
+
+    #[test]
+    fn non_trivial_elements_of_small_matrix() {
+        let matrix = SparseBinMat::new(3, vec![vec![1], vec![0, 2], vec![0, 1, 2]]);
+        let mut iter = NonTrivialElements::new(&matrix);
+
+        assert_eq!(iter.next(), Some((0, 1)));
+        assert_eq!(iter.next(), Some((1, 0)));
+        assert_eq!(iter.next(), Some((1, 2)));
+        assert_eq!(iter.next(), Some((2, 0)));
+        assert_eq!(iter.next(), Some((2, 1)));
+        assert_eq!(iter.next(), Some((2, 2)));
+        assert_eq!(iter.next(), None);
+    }
 }