modify the api layer, type annotations, the binder and the rust core

rustworkx-core/src/connectivity/minimum_cycle_basis.rs → rustworkx-core/src/connectivity/minimal_cycle_basis.rs

@@ -1,9 +1,9 @@
 use crate::connectivity::conn_components::connected_components;
 use crate::dictmap::*;
-use crate::shortest_path::dijkstra;
+use crate::shortest_path::{astar, dijkstra};
 use crate::Result;
 use hashbrown::{HashMap, HashSet};
-use petgraph::algo::{astar, min_spanning_tree, Measure};
+use petgraph::algo::{min_spanning_tree, Measure};
 use petgraph::csr::{DefaultIx, IndexType};
 use petgraph::data::{DataMap, Element};
 use petgraph::graph::Graph;
@@ -13,6 +13,7 @@ use petgraph::visit::{
     IntoNeighborsDirected, IntoNodeIdentifiers, IntoNodeReferences, NodeIndexable, Visitable,
 };
 use petgraph::Undirected;
+use std::cmp::Ordering;
 use std::convert::Infallible;
 use std::hash::Hash;
 
@@ -39,7 +40,7 @@ where
     G::NodeId: Eq + Hash,
     G::EdgeWeight: Clone,
     F: FnMut(G::EdgeRef) -> Result<K, E>,
-    K: Clone + PartialOrd + Copy + Measure + Default + Ord,
+    K: Clone + PartialOrd + Copy + Measure + Default,
 {
     components
         .into_iter()
@@ -77,7 +78,7 @@ where
         })
         .collect()
 }
-pub fn minimum_cycle_basis<G, F, K, E>(graph: G, mut weight_fn: F) -> Result<Vec<Vec<NodeIndex>>, E>
+pub fn minimal_cycle_basis<G, F, K, E>(graph: G, mut weight_fn: F) -> Result<Vec<Vec<NodeIndex>>, E>
 where
     G: EdgeCount
         + IntoNodeIdentifiers
@@ -88,10 +89,10 @@ where
         + IntoNeighborsDirected
         + Visitable
         + IntoEdges,
-    G::EdgeWeight: Clone + PartialOrd,
+    G::EdgeWeight: Clone,
     G::NodeId: Eq + Hash,
     F: FnMut(G::EdgeRef) -> Result<K, E>,
-    K: Clone + PartialOrd + Copy + Measure + Default + Ord,
+    K: Clone + PartialOrd + Copy + Measure + Default,
 {
     let conn_components = connected_components(&graph);
     let mut min_cycle_basis = Vec::new();
@@ -136,7 +137,7 @@ where
     H::EdgeWeight: Clone + PartialOrd,
     H::NodeId: Eq + Hash,
     F: FnMut(H::EdgeRef) -> Result<K, E>,
-    K: Clone + PartialOrd + Copy + Measure + Default + Ord,
+    K: Clone + PartialOrd + Copy + Measure + Default,
 {
     let mut sub_cb: Vec<Vec<usize>> = Vec::new();
     let num_edges = subgraph.edge_count();
@@ -243,7 +244,7 @@ where
     H: IntoNodeReferences + IntoEdgeReferences + DataMap + NodeIndexable + EdgeIndexable,
     H::NodeId: Eq + Hash,
     F: FnMut(H::EdgeRef) -> Result<K, E>,
-    K: Clone + PartialOrd + Copy + Measure + Default + Ord,
+    K: Clone + PartialOrd + Copy + Measure + Default,
 {
     let mut gi = Graph::<_, _, petgraph::Undirected>::default();
     let mut subgraph_gi_map = HashMap::new();
@@ -290,31 +291,36 @@ where
             |edge| Ok(*edge.weight()),
             None,
         );
-        // Find the shortest distance in the result and store it in the shortest_path_map
         let spl = result.unwrap()[&gi_lifted_nodeidx];
         shortest_path_map.insert(subnodeid, spl);
     }
-    let min_start = shortest_path_map.iter().min_by_key(|x| x.1).unwrap().0;
+    let min_start = shortest_path_map
+        .iter()
+        .min_by(|a, b| a.1.partial_cmp(b.1).unwrap_or(Ordering::Equal))
+        .unwrap()
+        .0;
     let min_start_node = subgraph_gi_map[min_start].0;
     let min_start_lifted_node = subgraph_gi_map[min_start].1;
-    let result = astar(
+    let result: Result<Option<(K, Vec<NodeIndex>)>> = astar(
         &gi,
-        min_start_node,
-        |finish| finish == min_start_lifted_node,
-        |e| *e.weight(),
-        |_| K::default(),
+        min_start_node.clone(),
+        |finish| Ok(finish == min_start_lifted_node.clone()),
+        |e| Ok(*e.weight()),
+        |_| Ok(K::default()),
     );
+
     let mut min_path: Vec<usize> = Vec::new();
     match result {
-        Some((_cost, path)) => {
+        Ok(Some((_cost, path))) => {
             for node in path {
                 if let Some(&subgraph_nodeid) = gi_subgraph_map.get(&node) {
                     let subgraph_node = NodeIndexable::to_index(&subgraph, subgraph_nodeid);
                     min_path.push(subgraph_node.index());
                 }
             }
         }
-        None => {}
+        Ok(None) => {}
+        Err(_) => {}
     }
     let edgelist = min_path
         .windows(2)
@@ -344,9 +350,9 @@ where
 }
 
 #[cfg(test)]
-mod test_minimum_cycle_basis {
-    use crate::connectivity::minimum_cycle_basis::minimum_cycle_basis;
-    use petgraph::graph::Graph;
+mod test_minimal_cycle_basis {
+    use crate::connectivity::minimal_cycle_basis::minimal_cycle_basis;
+    use petgraph::graph::{Graph, NodeIndex};
     use petgraph::Undirected;
     use std::convert::Infallible;
 
@@ -356,7 +362,7 @@ mod test_minimum_cycle_basis {
         let weight_fn = |edge: petgraph::graph::EdgeReference<i32>| -> Result<i32, Infallible> {
             Ok(*edge.weight())
         };
-        let output = minimum_cycle_basis(&graph, weight_fn).unwrap();
+        let output = minimal_cycle_basis(&graph, weight_fn).unwrap();
         assert_eq!(output.len(), 0);
     }
 
@@ -372,8 +378,7 @@ mod test_minimum_cycle_basis {
         let weight_fn = |edge: petgraph::graph::EdgeReference<i32>| -> Result<i32, Infallible> {
             Ok(*edge.weight())
         };
-        let cycles = minimum_cycle_basis(&graph, weight_fn);
-        println!("Cycles {:?}", cycles.as_ref().unwrap());
+        let cycles = minimal_cycle_basis(&graph, weight_fn);
         assert_eq!(cycles.unwrap().len(), 1);
     }
 
@@ -393,10 +398,60 @@ mod test_minimum_cycle_basis {
         let weight_fn = |edge: petgraph::graph::EdgeReference<i32>| -> Result<i32, Infallible> {
             Ok(*edge.weight())
         };
-        let cycles = minimum_cycle_basis(&graph, weight_fn);
+        let cycles = minimal_cycle_basis(&graph, weight_fn);
         assert_eq!(cycles.unwrap().len(), 2);
     }
 
+    #[test]
+    fn test_non_trivial_graph() {
+        let mut g = Graph::<&str, i32, Undirected>::new_undirected();
+        let a = g.add_node("A");
+        let b = g.add_node("B");
+        let c = g.add_node("C");
+        let d = g.add_node("D");
+        let e = g.add_node("E");
+        let f = g.add_node("F");
+
+        g.add_edge(a, b, 7);
+        g.add_edge(c, a, 9);
+        g.add_edge(a, d, 11);
+        g.add_edge(b, c, 10);
+        g.add_edge(d, c, 2);
+        g.add_edge(d, e, 9);
+        g.add_edge(b, f, 15);
+        g.add_edge(c, f, 11);
+        g.add_edge(e, f, 6);
+
+        let weight_fn = |edge: petgraph::graph::EdgeReference<i32>| -> Result<i32, Infallible> {
+            Ok(*edge.weight())
+        };
+        let output = minimal_cycle_basis(&g, weight_fn);
+        let mut actual_output = output.unwrap();
+        for cycle in &mut actual_output {
+            cycle.sort();
+        }
+        actual_output.sort();
+
+        let expected_output: Vec<Vec<NodeIndex>> = vec![
+            vec![
+                NodeIndex::new(5),
+                NodeIndex::new(2),
+                NodeIndex::new(3),
+                NodeIndex::new(4),
+            ],
+            vec![NodeIndex::new(2), NodeIndex::new(5), NodeIndex::new(1)],
+            vec![NodeIndex::new(0), NodeIndex::new(2), NodeIndex::new(1)],
+            vec![NodeIndex::new(2), NodeIndex::new(3), NodeIndex::new(0)],
+        ];
+        let mut sorted_expected_output = expected_output.clone();
+        for cycle in &mut sorted_expected_output {
+            cycle.sort();
+        }
+        sorted_expected_output.sort();
+
+        assert_eq!(actual_output, sorted_expected_output);
+    }
+
     #[test]
     fn test_weighted_diamond_graph() {
         let mut weighted_diamond = Graph::<(), i32, Undirected>::new_undirected();
@@ -412,20 +467,19 @@ mod test_minimum_cycle_basis {
         let weight_fn = |edge: petgraph::graph::EdgeReference<i32>| -> Result<i32, Infallible> {
             Ok(*edge.weight())
         };
-        let output = minimum_cycle_basis(&weighted_diamond, weight_fn);
-        let expected_output: Vec<Vec<usize>> = vec![vec![0, 1, 3], vec![0, 1, 2, 3]];
+        let output = minimal_cycle_basis(&weighted_diamond, weight_fn);
+        let expected_output1: Vec<Vec<usize>> = vec![vec![0, 1, 3], vec![0, 1, 2, 3]];
+        let expected_output2: Vec<Vec<usize>> = vec![vec![1, 2, 3], vec![0, 1, 2, 3]];
         for cycle in output.unwrap().iter() {
-            println!("{:?}", cycle);
             let mut node_indices: Vec<usize> = Vec::new();
             for node in cycle.iter() {
                 node_indices.push(node.index());
             }
             node_indices.sort();
-            println!("Node indices {:?}", node_indices);
-            if expected_output.contains(&node_indices) {
-                println!("Found cycle {:?}", node_indices);
-            }
-            assert!(expected_output.contains(&node_indices));
+            assert!(
+                expected_output1.contains(&node_indices)
+                    || expected_output2.contains(&node_indices)
+            );
         }
     }
 
@@ -444,7 +498,7 @@ mod test_minimum_cycle_basis {
         let weight_fn =
             |_edge: petgraph::graph::EdgeReference<()>| -> Result<i32, Infallible> { Ok(1) };
 
-        let output = minimum_cycle_basis(&unweighted_diamond, weight_fn);
+        let output = minimal_cycle_basis(&unweighted_diamond, weight_fn);
         let expected_output: Vec<Vec<usize>> = vec![vec![0, 1, 3], vec![1, 2, 3]];
         for cycle in output.unwrap().iter() {
             let mut node_indices: Vec<usize> = Vec::new();
@@ -476,7 +530,7 @@ mod test_minimum_cycle_basis {
         let weight_fn = |edge: petgraph::graph::EdgeReference<i32>| -> Result<i32, Infallible> {
             Ok(*edge.weight())
         };
-        let output = minimum_cycle_basis(&complete_graph, weight_fn);
+        let output = minimal_cycle_basis(&complete_graph, weight_fn);
         for cycle in output.unwrap().iter() {
             assert_eq!(cycle.len(), 3);
         }

rustworkx-core/src/connectivity/mod.rs

@@ -21,7 +21,7 @@ mod cycle_basis;
 mod find_cycle;
 mod isolates;
 mod min_cut;
-mod minimum_cycle_basis;
+mod minimal_cycle_basis;
 
 pub use all_simple_paths::{
     all_simple_paths_multiple_targets, longest_simple_path_multiple_targets,
@@ -37,4 +37,4 @@ pub use cycle_basis::cycle_basis;
 pub use find_cycle::find_cycle;
 pub use isolates::isolates;
 pub use min_cut::stoer_wagner_min_cut;
-pub use minimum_cycle_basis::minimum_cycle_basis;
+pub use minimal_cycle_basis::minimal_cycle_basis;

rustworkx/__init__.py

@@ -557,6 +557,32 @@ def all_pairs_dijkstra_path_lengths(graph, edge_cost_fn):
     raise TypeError("Invalid Input Type %s for graph" % type(graph))
 
 
+@_rustworkx_dispatch
+def minimum_cycle_basis(graph, edge_cost_fn):
+    """Find the minimum cycle basis of a graph.
+
+    This function will find the minimum cycle basis of a graph based on the
+    following papers
+    References:
+        [1] Kavitha, Telikepalli, et al. "An O(m^2n) Algorithm for
+        Minimum Cycle Basis of Graphs."
+        http://link.springer.com/article/10.1007/s00453-007-9064-z
+        [2] de Pina, J. 1995. Applications of shortest path methods.
+        Ph.D. thesis, University of Amsterdam, Netherlands
+
+    :param graph: The input graph to use. Can either be a
+        :class:`~rustworkx.PyGraph` or :class:`~rustworkx.PyDiGraph`
+    :param edge_cost_fn: A callable object that acts as a weight function for
+        an edge. It will accept a single positional argument, the edge's weight
+        object and will return a float which will be used to represent the
+        weight/cost of the edge
+
+    :return: A list of cycles where each cycle is a list of node indices
+
+    :rtype: list
+    """
+    raise TypeError("Invalid Input Type %s for graph" % type(graph))
+
 @_rustworkx_dispatch
 def dijkstra_shortest_path_lengths(graph, node, edge_cost_fn, goal=None):
     """Compute the lengths of the shortest paths for a graph object using

rustworkx/__init__.pyi

@@ -83,7 +83,7 @@ from .rustworkx import graph_longest_simple_path as graph_longest_simple_path
 from .rustworkx import digraph_core_number as digraph_core_number
 from .rustworkx import graph_core_number as graph_core_number
 from .rustworkx import stoer_wagner_min_cut as stoer_wagner_min_cut
-from .rustworkx import minimum_cycle_basis as minimum_cycle_basis
+from .rustworkx import graph_minimum_cycle_basis as graph_minimum_cycle_basis
 from .rustworkx import simple_cycles as simple_cycles
 from .rustworkx import digraph_isolates as digraph_isolates
 from .rustworkx import graph_isolates as graph_isolates

rustworkx/rustworkx.pyi

@@ -247,7 +247,7 @@ def stoer_wagner_min_cut(
     /,
     weight_fn: Callable[[_T], float] | None = ...,
 ) -> tuple[float, NodeIndices] | None: ...
-def minimum_cycle_basis(
+def graph_minimum_cycle_basis(
     graph: PyGraph[_S, _T], 
     /,
     weight_fn: Callable[[_T], float] | None = ...

src/connectivity/minimum_cycle_basis.rs

@@ -0,0 +1,41 @@
+use rustworkx_core::connectivity::minimal_cycle_basis;
+
+use pyo3::exceptions::PyIndexError;
+use pyo3::prelude::*;
+use pyo3::Python;
+
+use petgraph::graph::NodeIndex;
+use petgraph::prelude::*;
+use petgraph::visit::EdgeIndexable;
+use petgraph::EdgeType;
+
+use crate::{CostFn, StablePyGraph};
+
+pub fn minimum_cycle_basis_map<Ty: EdgeType + Sync>(
+    py: Python,
+    graph: &StablePyGraph<Ty>,
+    edge_cost_fn: PyObject,
+) -> PyResult<Vec<Vec<NodeIndex>>> {
+    if graph.node_count() == 0 {
+        return Ok(vec![]);
+    } else if graph.edge_count() == 0 {
+        return Ok(vec![]);
+    }
+    let edge_cost_callable = CostFn::from(edge_cost_fn);
+    let mut edge_weights: Vec<Option<f64>> = Vec::with_capacity(graph.edge_bound());
+    for index in 0..=graph.edge_bound() {
+        let raw_weight = graph.edge_weight(EdgeIndex::new(index));
+        match raw_weight {
+            Some(weight) => edge_weights.push(Some(edge_cost_callable.call(py, weight)?)),
+            None => edge_weights.push(None),
+        };
+    }
+    let edge_cost = |e: EdgeIndex| -> PyResult<f64> {
+        match edge_weights[e.index()] {
+            Some(weight) => Ok(weight),
+            None => Err(PyIndexError::new_err("No edge found for index")),
+        }
+    };
+    let cycle_basis = minimal_cycle_basis(graph, |e| edge_cost(e.id())).unwrap();
+    Ok(cycle_basis)
+}