WIP

Author: habedi

Cargo.toml

@@ -44,6 +44,7 @@ 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"
+ordered-float = "5.0.0"
 
 [dev-dependencies]
 criterion = { version = "0.5", features = ["html_reports"] }

README.md

@@ -23,35 +23,14 @@ set of ready-to-use algorithms for graph analysis and mining.
 
 ## Features
 
-* **Graphs**:
-    - [x] Directed and undirected graphs
-    - [x] Weighted and unweighted graphs
-
-* **IO**:
-    - [x] Edge list
-    - [x] Adjacency list
-    - [ ] GraphML
-    - [ ] GML
-    - [ ] JSON
-
-* **Generators**:
-    - [x] Erdős–Rényi Graph
-    - [x] Complete Graph
-    - [x] Bipartite Graph
-    - [x] Star Graph
-    - [x] Cycle Graph
-    - [x] Watts–Strogatz Graph
-    - [x] Barabási–Albert Graph
-
-* **Algorithms**:
-    - [ ] Graph traversal
-    - [ ] Shortest paths
-    - [ ] Minimum spanning tree
-    - [ ] Connected components
-    - [ ] Clustering, partitioning, and community detection
-    - [ ] Centrality
-    - [ ] Graph matching
-    - [ ] Graph visualization
+| Module                                    | Feature                                                                                                                                                                                     |
+|-------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [**Graphs**](src/graph/types.rs)          | - ✓ Directed and undirected graphs<br>- ✓ Weighted and unweighted graphs                                                                                                                    |
+| [**IO**](src/graph/io.rs)                 | - ✓ Edge list<br>- ✓ Adjacency list<br>- ☐ GraphML<br>- ☐ GML<br>- ☐ JSON                                                                                                                   |
+| [**Generators**](src/graph/generators.rs) | - ✓ Erdős–Rényi graph<br>- ✓ Watts–Strogatz graph<br>- ✓ Barabási–Albert graph<br>- ✓ Complete graph<br>- ✓ Bipartite graph<br>- ✓ Star graph<br>- ✓ Cycle graph                            |
+| [**Graph Traversal**](src/traversal/)     | - ✓ Breadth-first search<br>- ✓ Depth-first search<br>- ✓ Iterative deepening DFS<br>- ✓ Bidirectional search                                                                               |
+| [**Shortest Paths**](src/paths/)          | - ✓ Dijkstra's algorithm<br>- ✓ Bellman–Ford algorithm<br>- ✓ Floyd–Warshall algorithm<br>- ✓ Johnson's algorithm<br>- ✓ A* search algorithm<br>- ✓ Iterative deepening A* search algorithm |
+| **Remaining Modules**                     | - ☐ Minimum spanning tree<br>- ☐ Connected components<br>- ☐ Clustering, partitioning, and community detection<br>- ☐ Centrality<br>- ☐ Graph matching<br>- ☐ Graph visualization           |
 
 ## Installation
 

src/graph/generators.rs_ renamed to src/graph/generators.rs

@@ -1,5 +1,4 @@
-use crate::graph::types::{BaseGraph, GraphConstructor, MyEdgeType};
-use petgraph::EdgeType;
+use crate::graph::types::{BaseGraph, GraphConstructor};
 use rand::rngs::StdRng;
 use rand::{Rng, SeedableRng};
 
@@ -13,23 +12,23 @@ use rand::{Rng, SeedableRng};
 ///
 /// # Type Parameters
 ///
-/// * `Ty` - The edge type of the graph, which must implement
-///          `GraphConstructor<i32, f32> + MyEdgeType + EdgeType`.
+/// * `Ty` - The edge type of the graph, which must implement `GraphConstructor`.
 ///
 /// # Returns
 ///
-/// * `BaseGraph<i32, f32, Ty>` - The generated graph.
-pub fn erdos_renyi_graph<Ty>(n: usize, p: f64, seed: u64) -> BaseGraph<i32, f32, Ty>
-where
-    Ty: GraphConstructor<i32, f32> + MyEdgeType + EdgeType,
-{
-    let mut graph = BaseGraph::<i32, f32, Ty>::new();
+/// * `BaseGraph<u32, f32, Ty>` - The generated graph.
+pub fn erdos_renyi_graph<Ty: GraphConstructor<u32, f32>>(
+    n: usize,
+    p: f64,
+    seed: u64,
+) -> BaseGraph<u32, f32, Ty> {
+    let mut graph = BaseGraph::<u32, f32, Ty>::new();
     let mut nodes = Vec::with_capacity(n);
     for i in 0..n {
-        nodes.push(graph.add_node(i as i32));
+        nodes.push(graph.add_node(i as u32));
     }
     let mut rng = StdRng::seed_from_u64(seed);
-    if <Ty as GraphConstructor<i32, f32>>::is_directed() {
+    if <Ty as GraphConstructor<u32, f32>>::is_directed() {
         for i in 0..n {
             for j in 0..n {
                 if i != j && rng.random_bool(p) {
@@ -50,16 +49,25 @@ where
 }
 
 /// Generates a complete graph.
-pub fn complete_graph<Ty>(n: usize) -> BaseGraph<i32, f32, Ty>
-where
-    Ty: GraphConstructor<i32, f32> + MyEdgeType + EdgeType,
-{
-    let mut graph = BaseGraph::<i32, f32, Ty>::new();
+///
+/// # Arguments
+///
+/// * `n` - The number of nodes.
+///
+/// # Type Parameters
+///
+/// * `Ty` - The edge type of the graph, which must implement `GraphConstructor`.
+///
+/// # Returns
+///
+/// * `BaseGraph<u32, f32, Ty>` - The generated graph.
+pub fn complete_graph<Ty: GraphConstructor<u32, f32>>(n: usize) -> BaseGraph<u32, f32, Ty> {
+    let mut graph = BaseGraph::<u32, f32, Ty>::new();
     let mut nodes = Vec::with_capacity(n);
     for i in 0..n {
-        nodes.push(graph.add_node(i as i32));
+        nodes.push(graph.add_node(i as u32));
     }
-    if <Ty as GraphConstructor<i32, f32>>::is_directed() {
+    if <Ty as GraphConstructor<u32, f32>>::is_directed() {
         for i in 0..n {
             for j in 0..n {
                 if i != j {
@@ -78,18 +86,35 @@ where
 }
 
 /// Generates a bipartite graph.
-pub fn bipartite_graph<Ty>(n1: usize, n2: usize, p: f64, seed: u64) -> BaseGraph<i32, f32, Ty>
-where
-    Ty: GraphConstructor<i32, f32> + MyEdgeType + EdgeType,
-{
-    let mut graph = BaseGraph::<i32, f32, Ty>::new();
+///
+/// # Arguments
+///
+/// * `n1` - The number of nodes in the first set.
+/// * `n2` - The number of nodes in the second set.
+/// * `p` - The probability of edge creation.
+/// * `seed` - The seed for the random number generator.
+///
+/// # Type Parameters
+///
+/// * `Ty` - The edge type of the graph, which must implement `GraphConstructor`.
+///
+/// # Returns
+///
+/// * `BaseGraph<u32, f32, Ty>` - The generated graph.
+pub fn bipartite_graph<Ty: GraphConstructor<u32, f32>>(
+    n1: usize,
+    n2: usize,
+    p: f64,
+    seed: u64,
+) -> BaseGraph<u32, f32, Ty> {
+    let mut graph = BaseGraph::<u32, f32, Ty>::new();
     let mut group1 = Vec::with_capacity(n1);
     let mut group2 = Vec::with_capacity(n2);
     for i in 0..n1 {
-        group1.push(graph.add_node(i as i32));
+        group1.push(graph.add_node(i as u32));
     }
     for j in 0..n2 {
-        group2.push(graph.add_node((n1 + j) as i32));
+        group2.push(graph.add_node((n1 + j) as u32));
     }
     let mut rng = StdRng::seed_from_u64(seed);
     for &u in &group1 {
@@ -103,34 +128,52 @@ where
 }
 
 /// Generates a star graph.
-pub fn star_graph<Ty>(n: usize) -> BaseGraph<i32, f32, Ty>
-where
-    Ty: GraphConstructor<i32, f32> + MyEdgeType + EdgeType,
-{
-    let mut graph = BaseGraph::<i32, f32, Ty>::new();
+///
+/// # Arguments
+///
+/// * `n` - The number of nodes.
+///
+/// # Type Parameters
+///
+/// * `Ty` - The edge type of the graph, which must implement `GraphConstructor`.
+///
+/// # Returns
+///
+/// * `BaseGraph<u32, f32, Ty>` - The generated graph.
+pub fn star_graph<Ty: GraphConstructor<u32, f32>>(n: usize) -> BaseGraph<u32, f32, Ty> {
+    let mut graph = BaseGraph::<u32, f32, Ty>::new();
     if n == 0 {
         return graph;
     }
     let center = graph.add_node(0);
     for i in 1..n {
-        let node = graph.add_node(i as i32);
+        let node = graph.add_node(i as u32);
         graph.add_edge(center, node, 1.0);
     }
     graph
 }
 
 /// Generates a cycle graph.
-pub fn cycle_graph<Ty>(n: usize) -> BaseGraph<i32, f32, Ty>
-where
-    Ty: GraphConstructor<i32, f32> + MyEdgeType + EdgeType,
-{
-    let mut graph = BaseGraph::<i32, f32, Ty>::new();
+///
+/// # Arguments
+///
+/// * `n` - The number of nodes.
+///
+/// # Type Parameters
+///
+/// * `Ty` - The edge type of the graph, which must implement `GraphConstructor`.
+///
+/// # Returns
+///
+/// * `BaseGraph<u32, f32, Ty>` - The generated graph.
+pub fn cycle_graph<Ty: GraphConstructor<u32, f32>>(n: usize) -> BaseGraph<u32, f32, Ty> {
+    let mut graph = BaseGraph::<u32, f32, Ty>::new();
     if n == 0 {
         return graph;
     }
     let mut nodes = Vec::with_capacity(n);
     for i in 0..n {
-        nodes.push(graph.add_node(i as i32));
+        nodes.push(graph.add_node(i as u32));
     }
     for i in 0..n {
         let j = (i + 1) % n;
@@ -140,26 +183,44 @@ where
 }
 
 /// Generates a Watts–Strogatz small-world graph.
-pub fn watts_strogatz_graph<Ty>(n: usize, k: usize, beta: f64, seed: u64) -> BaseGraph<i32, f32, Ty>
-where
-    Ty: GraphConstructor<i32, f32> + MyEdgeType + EdgeType,
-{
+///
+/// # Arguments
+///
+/// * `n` - The number of nodes.
+/// * `k` - Each node is joined with its `k` nearest neighbors in a ring topology.
+/// * `beta` - The probability of rewiring each edge.
+/// * `seed` - The seed for the random number generator.
+///
+/// # Type Parameters
+///
+/// * `Ty` - The edge type of the graph, which must implement `GraphConstructor`.
+///
+/// # Returns
+///
+/// * `BaseGraph<u32, f32, Ty>` - The generated graph.
+pub fn watts_strogatz_graph<Ty: GraphConstructor<u32, f32>>(
+    n: usize,
+    k: usize,
+    beta: f64,
+    seed: u64,
+) -> BaseGraph<u32, f32, Ty> {
     // Watts–Strogatz is defined for undirected graphs.
-    let mut graph = BaseGraph::<i32, f32, Ty>::new();
+    let mut graph = BaseGraph::<u32, f32, Ty>::new();
     let mut nodes = Vec::with_capacity(n);
     for i in 0..n {
-        nodes.push(graph.add_node(i as i32));
+        nodes.push(graph.add_node(i as u32));
     }
     let mut rng = StdRng::seed_from_u64(seed);
     let half_k = k / 2;
-    // Create ring lattice.
+    // Create ring lattice
     for i in 0..n {
         for j in 1..=half_k {
             let neighbor = (i + j) % n;
             graph.add_edge(nodes[i], nodes[neighbor], 1.0);
         }
     }
     // Rewire each edge with probability beta.
+    // For simplicity, we add new edges for rewired connections.
     for i in 0..n {
         for _ in 1..=half_k {
             if rng.random_bool(beta) {
@@ -178,19 +239,34 @@ where
 }
 
 /// Generates a Barabási–Albert scale-free graph.
-pub fn barabasi_albert_graph<Ty>(n: usize, m: usize, seed: u64) -> BaseGraph<i32, f32, Ty>
-where
-    Ty: GraphConstructor<i32, f32> + MyEdgeType + EdgeType,
-{
+///
+/// # Arguments
+///
+/// * `n` - The number of nodes.
+/// * `m` - The number of edges to attach from a new node to existing nodes.
+/// * `seed` - The seed for the random number generator.
+///
+/// # Type Parameters
+///
+/// * `Ty` - The edge type of the graph, which must implement `GraphConstructor`.
+///
+/// # Returns
+///
+/// * `BaseGraph<u32, f32, Ty>` - The generated graph.
+pub fn barabasi_albert_graph<Ty: GraphConstructor<u32, f32>>(
+    n: usize,
+    m: usize,
+    seed: u64,
+) -> BaseGraph<u32, f32, Ty> {
     // Barabási–Albert is defined for undirected graphs.
-    let mut graph = BaseGraph::<i32, f32, Ty>::new();
+    let mut graph = BaseGraph::<u32, f32, Ty>::new();
     if n < m || m == 0 {
         return graph;
     }
     // Start with a complete graph of m nodes.
     let mut nodes = Vec::with_capacity(n);
     for i in 0..m {
-        nodes.push(graph.add_node(i as i32));
+        nodes.push(graph.add_node(i as u32));
     }
     for i in 0..m {
         for j in (i + 1)..m {
@@ -201,7 +277,7 @@ where
     let mut degrees: Vec<usize> = vec![m - 1; m];
     let mut total_degree = m * (m - 1);
     for i in m..n {
-        let new_node = graph.add_node(i as i32);
+        let new_node = graph.add_node(i as u32);
         nodes.push(new_node);
         let mut targets = Vec::new();
         while targets.len() < m {