nx-cugraph: add triangles and clustering algorithms

python/nx-cugraph/nx_cugraph/algorithms/bipartite/basic.py

@@ -26,6 +26,6 @@ def is_bipartite(G):
     G = _to_graph(G)
     # Counting triangles may not be the fastest way to do this, but it is simple.
     node_ids, triangles, is_single_node = _triangles(
-        G, None, symmetrize="union" if G.is_directed else None
+        G, None, symmetrize="union" if G.is_directed() else None
     )
     return int(cp.count_nonzero(triangles)) == 0

python/nx-cugraph/nx_cugraph/algorithms/cluster.py

@@ -70,8 +70,7 @@ def clustering(G, nodes=None, weight=None):
             return 0
         degree = int((G.src_indices == nodes).sum())
         return 2 * numer / (degree * (degree - 1))
-    # What about self-edges?
-    degrees = G._degrees_array()[node_ids]
+    degrees = G._degrees_array(ignore_selfloops=True)[node_ids]
     denom = degrees * (degrees - 1)
     results = 2 * triangles / denom
     results = cp.where(denom, results, 0)  # 0 where we divided by 0
@@ -91,8 +90,7 @@ def average_clustering(G, nodes=None, weight=None, count_zeros=True):
     node_ids, triangles, is_single_node = _triangles(G, nodes)
     if len(G) == 0:
         raise ZeroDivisionError
-    # What about self-edges?
-    degrees = G._degrees_array()[node_ids]
+    degrees = G._degrees_array(ignore_selfloops=True)[node_ids]
     if not count_zeros:
         mask = triangles != 0
         triangles = triangles[mask]
@@ -127,8 +125,7 @@ def transitivity(G):
     numer = int(triangles.sum())
     if numer == 0:
         return 0
-    # What about self-edges?
-    degrees = G._degrees_array()[node_ids]
+    degrees = G._degrees_array(ignore_selfloops=True)[node_ids]
     denom = int((degrees * (degrees - 1)).sum())
     return 2 * numer / denom
 

python/nx-cugraph/nx_cugraph/classes/digraph.py

@@ -177,8 +177,16 @@ def to_undirected(self, reciprocal=False, as_view=False):
     # Private methods #
     ###################
 
-    def _in_degrees_array(self):
-        return cp.bincount(self.dst_indices, minlength=self._N)
-
-    def _out_degrees_array(self):
-        return cp.bincount(self.src_indices, minlength=self._N)
+    def _in_degrees_array(self, *, ignore_selfloops=False):
+        dst_indices = self.dst_indices
+        if ignore_selfloops:
+            not_selfloops = self.src_indices != dst_indices
+            dst_indices = dst_indices[not_selfloops]
+        return cp.bincount(dst_indices, minlength=self._N)
+
+    def _out_degrees_array(self, *, ignore_selfloops=False):
+        src_indices = self.src_indices
+        if ignore_selfloops:
+            not_selfloops = src_indices != self.dst_indices
+            src_indices = src_indices[not_selfloops]
+        return cp.bincount(src_indices, minlength=self._N)

python/nx-cugraph/nx_cugraph/classes/graph.py

@@ -732,10 +732,17 @@ def _become(self, other: Graph):
         self.graph = graph
         return self
 
-    def _degrees_array(self):
-        degrees = cp.bincount(self.src_indices, minlength=self._N)
+    def _degrees_array(self, *, ignore_selfloops=False):
+        src_indices = self.src_indices
+        dst_indices = self.dst_indices
+        if ignore_selfloops:
+            not_selfloops = src_indices != dst_indices
+            src_indices = src_indices[not_selfloops]
+            if self.is_directed():
+                dst_indices = dst_indices[not_selfloops]
+        degrees = cp.bincount(src_indices, minlength=self._N)
         if self.is_directed():
-            degrees += cp.bincount(self.dst_indices, minlength=self._N)
+            degrees += cp.bincount(dst_indices, minlength=self._N)
         return degrees
 
     _in_degrees_array = _degrees_array

python/nx-cugraph/nx_cugraph/tests/test_cluster.py

@@ -0,0 +1,48 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import networkx as nx
+import pytest
+from packaging.version import parse
+
+nxver = parse(nx.__version__)
+
+if nxver.major == 3 and nxver.minor < 2:
+    pytest.skip("Need NetworkX >=3.2 to test clustering", allow_module_level=True)
+
+
+def test_selfloops():
+    G = nx.complete_graph(5)
+    H = nx.complete_graph(5)
+    H.add_edge(0, 0)
+    H.add_edge(1, 1)
+    H.add_edge(2, 2)
+    # triangles
+    expected = nx.triangles(G)
+    assert expected == nx.triangles(H)
+    assert expected == nx.triangles(G, backend="cugraph")
+    assert expected == nx.triangles(H, backend="cugraph")
+    # average_clustering
+    expected = nx.average_clustering(G)
+    assert expected == nx.average_clustering(H)
+    assert expected == nx.average_clustering(G, backend="cugraph")
+    assert expected == nx.average_clustering(H, backend="cugraph")
+    # clustering
+    expected = nx.clustering(G)
+    assert expected == nx.clustering(H)
+    assert expected == nx.clustering(G, backend="cugraph")
+    assert expected == nx.clustering(H, backend="cugraph")
+    # transitivity
+    expected = nx.transitivity(G)
+    assert expected == nx.transitivity(H)
+    assert expected == nx.transitivity(G, backend="cugraph")
+    assert expected == nx.transitivity(H, backend="cugraph")