WIP

Author: habedi

Cargo.toml

@@ -46,6 +46,7 @@ tracing = "0.1.41"
 tracing-subscriber = "0.3.19"
 petgraph = { version = "0.7.1", features = ["graphmap", "stable_graph", "matrix_graph", "serde-1", "rayon"] }
 rand = "0.9.0"
+sprs = "0.11.3"
 
 [dev-dependencies]
 criterion = { version = "0.5", features = ["html_reports"] }

src/graph/types.rs

@@ -3,6 +3,7 @@ use petgraph::graph::{EdgeIndex, Graph as PetGraph, NodeIndex};
 use petgraph::prelude::EdgeRef;
 use petgraph::visit::IntoNodeReferences;
 use petgraph::{Directed, Undirected};
+use sprs::{CsMat, TriMat};
 
 /// Trait for constructing graphs with specific edge types.
 pub trait GraphConstructor<A, W>: petgraph::EdgeType + Sized {
@@ -67,7 +68,7 @@ impl EdgeId {
     }
 }
 
-/// Base graph structure that wraps around `PetGraph`.
+/// Base graph structure that wraps around a petgraph instance.
 #[derive(Debug, Clone)]
 pub struct BaseGraph<A, W, Ty: GraphConstructor<A, W>> {
     inner: PetGraph<A, W, Ty>,
@@ -117,6 +118,7 @@ impl<A, W, Ty: GraphConstructor<A, W>> BaseGraph<A, W, Ty> {
         self.inner.neighbors(index).map(NodeId::new)
     }
 
+    /// Returns a reference to the attribute of a node.
     pub fn node_attr(&self, node: NodeId) -> Option<&A> {
         let index = NodeIndex::new(node.index());
         self.inner.node_weight(index)
@@ -146,17 +148,124 @@ impl<A, W, Ty: GraphConstructor<A, W>> BaseGraph<A, W, Ty> {
         })
     }
 
-    /// Returns a reference to the inner `PetGraph`.
-    pub fn inner(&self) -> &PetGraph<A, W, Ty> {
+    /// Returns a reference to the inner petgraph instance.
+    /// (Not exposed to the user as part of the public API.)
+    fn inner(&self) -> &PetGraph<A, W, Ty> {
         &self.inner
     }
 
-    /// Returns a mutable reference to the inner `PetGraph`.
-    pub fn inner_mut(&mut self) -> &mut PetGraph<A, W, Ty> {
+    /// Returns a mutable reference to the inner petgraph instance.
+    /// (Not exposed to the user as part of the public API.)
+    fn inner_mut(&mut self) -> &mut PetGraph<A, W, Ty> {
         &mut self.inner
     }
 }
 
+/// Dense matrix API using owned values.
+impl<A, W, Ty: GraphConstructor<A, W>> BaseGraph<A, W, Ty>
+where
+    W: Clone,
+{
+    /// Returns the adjacency matrix of the graph as a 2D vector.
+    ///
+    /// Each entry at `[i][j]` is an `Option<W>` which is `Some(w)` if an edge exists
+    /// from node `i` to node `j`, or `None` otherwise.
+    /// For undirected graphs, the matrix is symmetric.
+    pub fn to_adjacency_matrix(&self) -> Vec<Vec<Option<W>>> {
+        let n = self.node_count();
+        let mut matrix = vec![vec![None; n]; n];
+        for edge in self.inner().edge_references() {
+            let i = edge.source().index();
+            let j = edge.target().index();
+            matrix[i][j] = Some(edge.weight().clone());
+            if !<Ty as GraphConstructor<A, W>>::is_directed() {
+                matrix[j][i] = Some(edge.weight().clone());
+            }
+        }
+        matrix
+    }
+
+    /// Constructs a new graph from an adjacency matrix.
+    ///
+    /// The input is a slice of vectors, where each inner vector represents the outgoing edges
+    /// from a node. A value of `Some(w)` at position `[i][j]` indicates an edge from node `i` to node `j`
+    /// with weight `w`. For undirected graphs, only the upper triangle (including the diagonal)
+    /// of the matrix is considered.
+    ///
+    /// Node attributes are initialized using `A::default()`, so `A` must implement `Default`.
+    pub fn from_adjacency_matrix(matrix: &[Vec<Option<W>>]) -> Self
+    where
+        A: Default,
+    {
+        let n = matrix.len();
+        let mut graph = Self::new();
+        // Add n nodes with default attributes.
+        let nodes: Vec<NodeId> = (0..n).map(|_| graph.add_node(A::default())).collect();
+        // Insert edges based on the matrix.
+        for i in 0..n {
+            for j in 0..matrix[i].len() {
+                if let Some(weight) = &matrix[i][j] {
+                    if <Ty as GraphConstructor<A, W>>::is_directed() || i <= j {
+                        graph.add_edge(nodes[i], nodes[j], weight.clone());
+                    }
+                }
+            }
+        }
+        graph
+    }
+}
+
+/// Sparse matrix API using sprs for efficiency on large graphs.
+/// The trait bound now includes Add so that duplicate entries can be combined.
+impl<A, W, Ty: GraphConstructor<A, W>> BaseGraph<A, W, Ty>
+where
+    W: Clone + std::ops::Add<Output = W>,
+{
+    /// Returns the sparse adjacency matrix of the graph as a CsMat in CSR format.
+    ///
+    /// Only existing edges are stored. For undirected graphs, both (i,j) and (j,i) are inserted,
+    /// except for self-loops.
+    pub fn to_sparse_adjacency_matrix(&self) -> CsMat<W> {
+        let n = self.node_count();
+        let mut triplet = TriMat::new((n, n));
+        for edge in self.inner().edge_references() {
+            let i = edge.source().index();
+            let j = edge.target().index();
+            triplet.add_triplet(i, j, edge.weight().clone());
+            if !<Ty as GraphConstructor<A, W>>::is_directed() && i != j {
+                triplet.add_triplet(j, i, edge.weight().clone());
+            }
+        }
+        // Convert the triplet matrix into CSR format.
+        triplet.to_csr()
+    }
+
+    /// Constructs a new graph from a sparse adjacency matrix.
+    ///
+    /// The input is a CsMat (typically in CSR format) where nonzero entries represent edges with their weights.
+    /// For undirected graphs, only one of the symmetric entries is used (edges with i <= j).
+    ///
+    /// Node attributes are initialized using `A::default()`, so `A` must implement `Default`.
+    pub fn from_sparse_adjacency_matrix(sparse: &CsMat<W>) -> Self
+    where
+        A: Default,
+    {
+        let n = sparse.rows();
+        let mut graph = Self::new();
+        let nodes: Vec<NodeId> = (0..n).map(|_| graph.add_node(A::default())).collect();
+        // Iterate over the outer (row) indices.
+        for (i, row) in sparse.outer_iterator().enumerate() {
+            // row.indices() gives column indices and row.data() gives the corresponding weights.
+            for (&j, weight) in row.indices().iter().zip(row.data().iter()) {
+                if <Ty as GraphConstructor<A, W>>::is_directed() || i <= j {
+                    graph.add_edge(nodes[i], nodes[j], weight.clone());
+                }
+            }
+        }
+        graph
+    }
+}
+
 /// Type alias for a directed graph.
 pub type Digraph<A, W> = BaseGraph<A, W, Directed>;
 /// Type alias for an undirected graph.

tests/graph/types_tests.rs

@@ -1,16 +1,14 @@
-use network::graph::{Digraph, Graph, NodeId};
-
 #[test]
-fn integration_test_digraph() {
+fn test_digraph() {
     // Create a directed graph with integer node attributes and f32 edge weights.
     let mut dgraph = Digraph::<i32, f32>::new();
     let n1 = dgraph.add_node(1);
     let n2 = dgraph.add_node(2);
     let n3 = dgraph.add_node(3);
 
-    let e1 = dgraph.add_edge(n1, n2, 1.0);
-    let e2 = dgraph.add_edge(n2, n3, 2.0);
-    let e3 = dgraph.add_edge(n3, n1, 3.0);
+    let _e1 = dgraph.add_edge(n1, n2, 1.0);
+    let _e2 = dgraph.add_edge(n2, n3, 2.0);
+    let _e3 = dgraph.add_edge(n3, n1, 3.0);
 
     // Verify counts.
     assert_eq!(dgraph.node_count(), 3);
@@ -27,29 +25,40 @@ fn integration_test_digraph() {
     assert_eq!(*dgraph.node_attr(n3).unwrap(), 3);
 
     // Verify edge attributes.
-    assert_eq!(*dgraph.edge_attr(e1).unwrap(), 1.0);
-    assert_eq!(*dgraph.edge_attr(e2).unwrap(), 2.0);
-    assert_eq!(*dgraph.edge_attr(e3).unwrap(), 3.0);
+    // (Using the dense API here.)
+    let matrix = dgraph.to_adjacency_matrix();
+    assert_eq!(matrix[0][1], Some(1.0));
+    assert_eq!(matrix[1][2], Some(2.0));
+    assert_eq!(matrix[2][0], Some(3.0));
+
+    // Test sparse conversion.
+    let sparse = dgraph.to_sparse_adjacency_matrix();
+    assert_eq!(sparse.rows(), 3);
+    // Check a few nonzero values.
+    assert_eq!(sparse.get(0, 1), Some(&1.0));
+    assert_eq!(sparse.get(1, 2), Some(&2.0));
+    assert_eq!(sparse.get(2, 0), Some(&3.0));
 
     // Update node attribute and verify.
     dgraph.update_node(n1, 10);
     assert_eq!(*dgraph.node_attr(n1).unwrap(), 10);
 }
 
 #[test]
-fn integration_test_graph() {
+fn test_graph() {
     // Create an undirected graph with string node attributes and unweighted edges.
     let mut graph = Graph::<&str, ()>::new();
     let a = graph.add_node("A");
     let b = graph.add_node("B");
     let c = graph.add_node("C");
 
-    let e1 = graph.add_edge(a, b, ());
-    let e2 = graph.add_edge(b, c, ());
-    let e3 = graph.add_edge(c, a, ());
+    let _e1 = graph.add_edge(a, b, ());
+    let _e2 = graph.add_edge(b, c, ());
+    let _e3 = graph.add_edge(c, a, ());
 
     // Verify counts.
     assert_eq!(graph.node_count(), 3);
+    // For undirected graphs, our API adds one edge per pair.
     assert_eq!(graph.edge_count(), 3);
 
     // In an undirected graph, neighbors should include all connected nodes.
@@ -63,9 +72,17 @@ fn integration_test_graph() {
     assert_eq!(graph.node_attr(c).unwrap(), &"C");
 
     // For unweighted edges, edge_attr returns the unit type `()`.
-    assert_eq!(graph.edge_attr(e1).unwrap(), &());
-    assert_eq!(graph.edge_attr(e2).unwrap(), &());
-    assert_eq!(graph.edge_attr(e3).unwrap(), &());
+    let matrix = graph.to_adjacency_matrix();
+    // Each edge appears twice in the dense matrix for an undirected graph.
+    assert_eq!(matrix[a.index()][b.index()], Some(()));
+    assert_eq!(matrix[b.index()][c.index()], Some(()));
+    assert_eq!(matrix[c.index()][a.index()], Some(()));
+
+    // Test sparse conversion.
+    let sparse = graph.to_sparse_adjacency_matrix();
+    assert_eq!(sparse.rows(), 3);
+    // Check one of the symmetric entries.
+    assert_eq!(sparse.get(a.index(), b.index()), Some(&()));
 
     // Update node attribute and verify.
     graph.update_node(a, "Alpha");