Merge #329 #330 #331

329: Add Matrix::map() r=samueltardieu a=samueltardieu



330: grid r=samueltardieu a=samueltardieu

- Add Matrix::map()
- Add Grid equality
- Add Matrix<bool> to Grid conversion


331: Do not run tests systematically on pull request r=samueltardieu a=samueltardieu



Co-authored-by: Samuel Tardieu <sam@rfc1149.net>

Author: bors[bot]

.github/workflows/tests.yml

@@ -3,7 +3,6 @@ on:
     branches:
       - staging
       - trying
-  pull_request:
 
 name: Continuous integration
 

src/grid.rs

@@ -1,15 +1,15 @@
 //! Rectangular grid in which vertices can be added or removed, with or
 //! without diagonal links.
 
+use super::matrix::Matrix;
+use super::utils::absdiff;
 use crate::directed::bfs::bfs_reach;
 use indexmap::IndexSet;
 use itertools::iproduct;
 use std::collections::BTreeSet;
 use std::fmt;
 use std::iter::{FromIterator, FusedIterator};
 
-use super::utils::absdiff;
-
 #[derive(Clone)]
 /// Representation of a rectangular grid in which vertices can be added
 /// or removed. Edges are automatically created between adjacent vertices.
@@ -560,3 +560,30 @@ impl fmt::Debug for Grid {
         Ok(())
     }
 }
+
+impl From<&Matrix<bool>> for Grid {
+    fn from(matrix: &Matrix<bool>) -> Self {
+        let mut grid = Grid::new(matrix.columns, matrix.rows);
+        for ((r, c), &v) in matrix.indices().zip(matrix.values()) {
+            if v {
+                grid.add_vertex((c, r));
+            }
+        }
+        grid
+    }
+}
+
+impl From<Matrix<bool>> for Grid {
+    fn from(matrix: Matrix<bool>) -> Self {
+        Grid::from(&matrix)
+    }
+}
+
+impl PartialEq for Grid {
+    fn eq(&self, other: &Self) -> bool {
+        self.vertices_len() == other.vertices_len()
+            && self.iter().zip(other.iter()).all(|(a, b)| a == b)
+    }
+}
+
+impl Eq for Grid {}

src/matrix.rs

@@ -166,6 +166,19 @@ impl<C: Clone> Matrix<C> {
         }
         Ok(())
     }
+
+    /// Transform the matrix into another matrix with the same shape
+    /// after applying a transforming function to every elements.
+    pub fn map<O, F>(self, transform: F) -> Matrix<O>
+    where
+        F: FnMut(C) -> O,
+    {
+        Matrix {
+            rows: self.rows,
+            columns: self.columns,
+            data: self.data.into_iter().map(transform).collect(),
+        }
+    }
 }
 
 impl<C: Copy> Matrix<C> {

tests/grid.rs

@@ -470,3 +470,48 @@ fn debug() {
         )
     );
 }
+
+#[test]
+fn from_matrix() {
+    let m = pathfinding::prelude::Matrix::square_from_vec(vec![
+        true, true, true, false, false, false, true, false, true,
+    ])
+    .unwrap();
+    let g = Grid::from(&m);
+    let g2 = Grid::from(m);
+    assert_eq!(g, g2);
+    let mut vertices = g.into_iter().collect::<Vec<_>>();
+    vertices.sort_unstable();
+    assert_eq!(vertices, vec![(0, 0), (0, 2), (1, 0), (2, 0), (2, 2)]);
+}
+
+#[test]
+fn test_equality() {
+    let g = [
+        (0, 0),
+        (1, 0),
+        (2, 0),
+        (3, 0),
+        (4, 0),
+        (0, 1),
+        (4, 1),
+        (0, 2),
+        (4, 2),
+        (0, 3),
+        (4, 3),
+        (0, 4),
+        (1, 4),
+        (2, 4),
+        (3, 4),
+        (4, 4),
+    ]
+    .into_iter()
+    .collect::<Grid>();
+    assert_eq!(g, g);
+    let mut g2 = g.clone();
+    assert_eq!(g, g2);
+    g2.remove_vertex((0, 0));
+    assert_ne!(g, g2);
+    g2.add_vertex((0, 0));
+    assert_eq!(g, g2);
+}

tests/matrix.rs

@@ -590,3 +590,19 @@ fn uninit() {
         }
     }
 }
+
+#[test]
+fn map() {
+    let m = Matrix::new(3, 3, 10);
+    let m = m.map({
+        let mut counter = 0;
+        move |x| {
+            counter += 1;
+            x + counter
+        }
+    });
+    assert_eq!(
+        m,
+        Matrix::square_from_vec(vec![11, 12, 13, 14, 15, 16, 17, 18, 19]).unwrap()
+    );
+}