modified the binder and API layer

rustworkx/__init__.py

@@ -570,15 +570,14 @@ def minimum_cycle_basis(graph, edge_cost_fn):
  [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
+ :param graph: The input graph to use. Can be either 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
-
+ :returns: 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/__init__.pyi

@@ -84,6 +84,7 @@ 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 graph_minimum_cycle_basis as graph_minimum_cycle_basis
+from .rustworkx import digraph_minimum_cycle_basis as digraph_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

@@ -15,6 +15,7 @@ from typing import (
  Callable,
  Iterable,
  Iterator,
+ Union,
  final,
  Sequence,
  Any,
@@ -248,8 +249,15 @@ def stoer_wagner_min_cut(
  weight_fn: Callable[[_T], float] | None = ...,
 ) -> tuple[float, NodeIndices] | None: ...
 def graph_minimum_cycle_basis(
- graph: PyGraph[_S, _T], /, weight_fn: Callable[[_T], float] | None = ...
-) -> list[list[NodeIndices]] | None: ...
+ graph: PyGraph[_S, _T],
+ edge_cost: Callable[[_T], float],
+ /,
+) -> list[list[NodeIndices]]: ...
+def digraph_minimum_cycle_basis(
+ graph: PyDiGraph[_S, _T],
+ edge_cost: Callable[[_T], float],
+ /,
+) -> list[list[NodeIndices]]: ...
 def simple_cycles(graph: PyDiGraph, /) -> Iterator[NodeIndices]: ...
 def graph_isolates(graph: PyGraph) -> NodeIndices: ...
 def digraph_isolates(graph: PyDiGraph) -> NodeIndices: ...

src/connectivity/minimum_cycle_basis.rs → src/connectivity/min_cycle_basis.rs

@@ -4,18 +4,17 @@ use pyo3::exceptions::PyIndexError;
 use pyo3::prelude::*;
 use pyo3::Python;
 
-use petgraph::graph::NodeIndex;
+use crate::iterators::NodeIndices;
+use crate::{CostFn, StablePyGraph};
 use petgraph::prelude::*;
 use petgraph::visit::EdgeIndexable;
 use petgraph::EdgeType;
 
-use crate::{CostFn, StablePyGraph};
-
-pub fn minimum_cycle_basis_map<Ty: EdgeType + Sync>(
+pub fn minimum_cycle_basis<Ty: EdgeType + Sync>(
  py: Python,
  graph: &StablePyGraph<Ty>,
  edge_cost_fn: PyObject,
-) -> PyResult<Vec<Vec<NodeIndex>>> {
+) -> PyResult<Vec<Vec<NodeIndices>>> {
  if graph.node_count() == 0 || graph.edge_count() == 0 {
  return Ok(vec![]);
  }
@@ -35,5 +34,17 @@ pub fn minimum_cycle_basis_map<Ty: EdgeType + Sync>(
  }
  };
  let cycle_basis = minimal_cycle_basis(graph, |e| edge_cost(e.id())).unwrap();
- Ok(cycle_basis)
+ // Convert the cycle basis to a list of lists of node indices
+ let result: Vec<Vec<NodeIndices>> = cycle_basis
+ .into_iter()
+ .map(|cycle| {
+ cycle
+ .into_iter()
+ .map(|node| NodeIndices {
+ nodes: vec![node.index()],
+ })
+ .collect()
+ })
+ .collect();
+ Ok(result)
 }

src/connectivity/mod.rs

@@ -14,7 +14,7 @@
 
 mod all_pairs_all_simple_paths;
 mod johnson_simple_cycles;
-mod minimum_cycle_basis;
+mod min_cycle_basis;
 mod subgraphs;
 
 use super::{
@@ -919,25 +919,54 @@ pub fn stoer_wagner_min_cut(
  }))
 }
 
+/// Find a minimum cycle basis of an undirected graph.
+/// All weights must be nonnegative. If the input graph does not have
+/// any nodes or edges, this function returns ``None``.
+/// If the input graph does not any weight, this function will find the
+/// minimum cycle basis with the weight of 1.0 for all edges.
+///
+/// :param PyGraph: The undirected graph to be used
+/// :param Callable edge_cost_fn: An optional callable object (function, lambda, etc) which
+/// will be passed the edge object and expected to return a ``float``.
+/// Edges with ``NaN`` weights will be considered to have 1.0 weight.
+/// If ``edge_cost_fn`` is not specified a default value of ``1.0`` will be used for all edges.
+///
+/// :returns: A list of cycles, where each cycle is a list of node indices
+/// :rtype: list
 #[pyfunction]
 #[pyo3(text_signature = "(graph, edge_cost_fn, /)")]
 pub fn graph_minimum_cycle_basis(
  py: Python,
  graph: &graph::PyGraph,
  edge_cost_fn: PyObject,
 ) -> PyResult<Vec<Vec<NodeIndices>>> {
- let basis = minimum_cycle_basis::minimum_cycle_basis_map(py, &graph.graph, edge_cost_fn);
- Ok(basis
- .into_iter()
- .map(|cycle| {
- cycle
- .into_iter()
- .map(|node| NodeIndices {
- nodes: node.iter().map(|nx| nx.index()).collect(),
- })
- .collect()
- })
- .collect())
+ min_cycle_basis::minimum_cycle_basis(py, &graph.graph, edge_cost_fn)
+}
+
+/// Find a minimum cycle basis of a directed graph (which is not of interest in the context
+/// of minimum cycle basis). This function will return the minimum cycle basis of the
+/// underlying undirected graph of the input directed graph.
+/// All weights must be nonnegative. If the input graph does not have
+/// any nodes or edges, this function returns ``None``.
+/// If the input graph does not any weight, this function will find the
+/// minimum cycle basis with the weight of 1.0 for all edges.
+///
+/// :param PyDiGraph: The directed graph to be used
+/// :param Callable edge_cost_fn: An optional callable object (function, lambda, etc) which
+/// will be passed the edge object and expected to return a ``float``.
+/// Edges with ``NaN`` weights will be considered to have 1.0 weight.
+/// If ``edge_cost_fn`` is not specified a default value of ``1.0`` will be used for all edges.
+///
+/// :returns: A list of cycles, where each cycle is a list of node indices
+/// :rtype: list
+#[pyfunction]
+#[pyo3(text_signature = "(graph, edge_cost_fn, /)")]
+pub fn digraph_minimum_cycle_basis(
+ py: Python,
+ graph: &digraph::PyDiGraph,
+ edge_cost_fn: PyObject,
+) -> PyResult<Vec<Vec<NodeIndices>>> {
+ min_cycle_basis::minimum_cycle_basis(py, &graph.graph, edge_cost_fn)
 }
 
 /// Return the articulation points of an undirected graph.

src/lib.rs

@@ -571,6 +571,7 @@ fn rustworkx(py: Python<'_>, m: &Bound<PyModule>) -> PyResult<()> {
  m.add_wrapped(wrap_pyfunction!(metric_closure))?;
  m.add_wrapped(wrap_pyfunction!(stoer_wagner_min_cut))?;
  m.add_wrapped(wrap_pyfunction!(graph_minimum_cycle_basis))?;
+ m.add_wrapped(wrap_pyfunction!(digraph_minimum_cycle_basis))?;
  m.add_wrapped(wrap_pyfunction!(steiner_tree::steiner_tree))?;
  m.add_wrapped(wrap_pyfunction!(digraph_dfs_search))?;
  m.add_wrapped(wrap_pyfunction!(graph_dfs_search))?;