Fixed changes

Author: Gohlub

.gitignore

@@ -22,5 +22,4 @@ retworkx/*pyd
 *.jpg
 **/*.so
 retworkx-core/Cargo.lock
-.DS_Store
 **/.DS_Store

degree_centrality_implementation_rustworkx.md

@@ -32,6 +32,7 @@ use petgraph::visit::{
     Reversed,
     Visitable,
 };
+use petgraph::Direction;
 use rayon_cond::CondIterator;
 
 /// Compute the betweenness centrality of all nodes in a graph.
@@ -362,7 +363,7 @@ fn accumulate_edges<G>(
 /// }
 /// ```
 
-pub fn degree_centrality<G>(graph: G) -> Vec<f64>
+pub fn graph_degree_centrality<G>(graph: G) -> Vec<f64>
 where
     G: IntoNodeIdentifiers + NodeCount + IntoNeighbors + NodeIndexable,
 {
@@ -377,6 +378,29 @@ where
     centrality
 }
 
+pub fn digraph_degree_centrality<G>(graph: G, direction: Option<Direction>) -> Vec<f64>
+where
+    G: IntoNodeIdentifiers + NodeCount + IntoNeighborsDirected + NodeIndexable,
+{
+    let node_count = graph.node_count() as f64;
+    let mut centrality = vec![0.0; graph.node_bound()];
+
+    for node in graph.node_identifiers() {
+        let degree = match direction {
+            Some(Direction::Incoming) => {
+                graph.neighbors_directed(node, Direction::Incoming).count() as f64
+            }
+            Some(Direction::Outgoing) => {
+                graph.neighbors_directed(node, Direction::Outgoing).count() as f64
+            }
+            _ => graph.neighbors(node).count() as f64,
+        };
+        centrality[graph.to_index(node)] = degree / (node_count - 1.0);
+    }
+
+    centrality
+}
+
 struct ShortestPathData<G>
 where
     G: GraphBase,

rustworkx-core/src/centrality.rs

@@ -50,7 +50,8 @@ from .rustworkx import digraph_closeness_centrality as digraph_closeness_central
 from .rustworkx import graph_closeness_centrality as graph_closeness_centrality
 from .rustworkx import digraph_katz_centrality as digraph_katz_centrality
 from .rustworkx import graph_katz_centrality as graph_katz_centrality
-from .rustworkx import degree_centrality as degree_centrality
+from .rustworkx import graph_degree_centrality as graph_degree_centrality
+from .rustworkx import digraph_degree_centrality as digraph_degree_centrality
 from .rustworkx import graph_greedy_color as graph_greedy_color
 from .rustworkx import graph_greedy_edge_color as graph_greedy_edge_color
 from .rustworkx import graph_is_bipartite as graph_is_bipartite

rustworkx/__init__.pyi

@@ -176,8 +176,22 @@ pub fn digraph_betweenness_centrality(
 /// :rtype: CentralityMapping
 #[pyfunction]
 #[pyo3(text_signature = "(graph, /)")]
-pub fn degree_centrality_py(graph: &graph::PyGraph) -> PyResult<CentralityMapping> {
-    let centrality = centrality::degree_centrality(&graph.graph);
+pub fn graph_degree_centrality(graph: &graph::PyGraph) -> PyResult<CentralityMapping> {
+    let centrality = centrality::graph_degree_centrality(&graph.graph);
+
+    Ok(CentralityMapping {
+        centralities: centrality
+            .into_iter()
+            .enumerate()
+            .map(|(i, v)| (i, v))
+            .collect(),
+    })
+}
+
+#[pyfunction]
+#[pyo3(text_signature = "(graph, /)")]
+pub fn digraph_degree_centrality(graph: &digraph::PyDiGraph) -> PyResult<CentralityMapping> {
+    let centrality = centrality::digraph_degree_centrality(&graph.graph, None);
 
     Ok(CentralityMapping {
         centralities: centrality

src/centrality.rs

@@ -533,7 +533,8 @@ fn rustworkx(py: Python<'_>, m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(digraph_eigenvector_centrality))?;
     m.add_wrapped(wrap_pyfunction!(graph_katz_centrality))?;
     m.add_wrapped(wrap_pyfunction!(digraph_katz_centrality))?;
-    m.add_wrapped(wrap_pyfunction!(degree_centrality_py))?;
+    m.add_wrapped(wrap_pyfunction!(graph_degree_centrality))?;
+    m.add_wrapped(wrap_pyfunction!(digraph_degree_centrality))?;
     m.add_wrapped(wrap_pyfunction!(graph_astar_shortest_path))?;
     m.add_wrapped(wrap_pyfunction!(digraph_astar_shortest_path))?;
     m.add_wrapped(wrap_pyfunction!(graph_greedy_color))?;

src/lib.rs

@@ -232,7 +232,7 @@ def test_custom_graph_unnormalized(self):
             self.assertAlmostEqual(v, expected[k])
 
 
-class TestDegreeCentrality(unittest.TestCase):
+class TestGraphDegreeCentrality(unittest.TestCase):
     def setUp(self):
         self.graph = rustworkx.PyGraph()
         self.a = self.graph.add_node("A")
@@ -247,7 +247,7 @@ def setUp(self):
         self.graph.add_edges_from(edge_list)
 
     def test_degree_centrality(self):
-        centrality = rustworkx.degree_centrality_py(self.graph)
+        centrality = rustworkx.graph_degree_centrality(self.graph)
         expected = {
             0: 1 / 3,  # Node A has 1 edge, normalized by (n-1) = 3
             1: 2 / 3,  # Node B has 2 edges
@@ -258,18 +258,62 @@ def test_degree_centrality(self):
 
     def test_degree_centrality_complete_graph(self):
         graph = rustworkx.generators.complete_graph(5)
-        centrality = rustworkx.degree_centrality_py(graph)
+        centrality = rustworkx.graph_degree_centrality(graph)
         expected = {0: 1.0, 1: 1.0, 2: 1.0, 3: 1.0, 4: 1.0}
         self.assertEqual(expected, centrality)
 
     def test_degree_centrality_star_graph(self):
         graph = rustworkx.generators.star_graph(5)
-        centrality = rustworkx.degree_centrality_py(graph)
+        centrality = rustworkx.graph_degree_centrality(graph)
         expected = {0: 1.0, 1: 0.25, 2: 0.25, 3: 0.25, 4: 0.25}
         self.assertEqual(expected, centrality)
 
     def test_degree_centrality_empty_graph(self):
         graph = rustworkx.PyGraph()
-        centrality = rustworkx.degree_centrality_py(graph)
+        centrality = rustworkx.graph_degree_centrality(graph)
         expected = {}
         self.assertEqual(expected, centrality)
+
+class TestDiGraphDegreeCentrality(unittest.TestCase):
+    def setUp(self):
+        self.digraph = rustworkx.PyDiGraph()
+        self.a = self.digraph.add_node("A")
+        self.b = self.digraph.add_node("B")
+        self.c = self.digraph.add_node("C")
+        self.d = self.digraph.add_node("D")
+        edge_list = [
+            (self.a, self.b, 1),
+            (self.b, self.c, 1),
+            (self.c, self.d, 1),
+        ]
+        self.digraph.add_edges_from(edge_list)
+
+    def test_digraph_degree_centrality(self):
+        centrality = rustworkx.digraph_degree_centrality(self.digraph)
+        expected = {
+            0: 1 / 3,  # Node A has 1 outgoing edge
+            1: 2 / 3,  # Node B has 1 incoming and 1 outgoing edge
+            2: 2 / 3,  # Node C has 1 incoming and 1 outgoing edge
+            3: 1 / 3,  # Node D has 1 incoming edge
+        }
+        self.assertEqual(expected, centrality)
+
+    def test_digraph_degree_centrality_with_direction(self):
+        centrality_incoming = rustworkx.digraph_degree_centrality(self.digraph, direction=rustworkx.Direction.Incoming)
+        expected_incoming = {
+            0: 0.0,  # Node A has 0 incoming edges
+            1: 1 / 3,  # Node B has 1 incoming edge
+            2: 1 / 3,  # Node C has 1 incoming edge
+            3: 1 / 3,  # Node D has 1 incoming edge
+        }
+        self.assertEqual(expected_incoming, centrality_incoming)
+
+        centrality_outgoing = rustworkx.digraph_degree_centrality(self.digraph, direction=rustworkx.Direction.Outgoing)
+        expected_outgoing = {
+            0: 1 / 3,  # Node A has 1 outgoing edge
+            1: 1 / 3,  # Node B has 1 outgoing edge
+            2: 1 / 3,  # Node C has 1 outgoing edge
+            3: 0.0,  # Node D has 0 outgoing edges
+        }
+        self.assertEqual(expected_outgoing, centrality_outgoing)
+