Add Graph and DiGraph classes for graphblas, which also cache properties. (#8)

Author: eriknw

graphblas_algorithms/__init__.py

@@ -1,4 +1,5 @@
 from . import _version
 from .algorithms import *
+from .classes import *
 
 __version__ = _version.get_versions()["version"]

graphblas_algorithms/algorithms/cluster.py

@@ -1,78 +1,26 @@
-import graphblas as gb
-import networkx as nx
-from graphblas import binary, select
+from graphblas import binary
 from graphblas.semiring import plus_pair
 from networkx import average_clustering as _nx_average_clustering
 from networkx import clustering as _nx_clustering
-from networkx.utils import not_implemented_for
 
-from graphblas_algorithms._utils import graph_to_adjacency, list_to_mask, vector_to_dict
+from graphblas_algorithms.classes.digraph import to_graph
+from graphblas_algorithms.classes.graph import to_undirected_graph
+from graphblas_algorithms.utils import not_implemented_for
 
 
-def get_properties(G, names, *, L=None, U=None, degrees=None, has_self_edges=True):
-    """Calculate properties of undirected graph"""
-    if isinstance(names, str):
-        # Separated by commas and/or spaces
-        names = [name for name in names.replace(" ", ",").split(",") if name]
-    rv = []
-    for name in names:
-        if name == "L":
-            if L is None:
-                L = select.tril(G, -1).new(name="L")
-            rv.append(L)
-        elif name == "U":
-            if U is None:
-                U = select.triu(G, 1).new(name="U")
-            rv.append(U)
-        elif name == "degrees":
-            if degrees is None:
-                degrees = get_degrees(G, L=L, U=U, has_self_edges=has_self_edges)
-            rv.append(degrees)
-        elif name == "has_self_edges":
-            # Compute if cheap
-            if L is not None:
-                has_self_edges = G.nvals > 2 * L.nvals
-            elif U is not None:
-                has_self_edges = G.nvals > 2 * U.nvals
-            rv.append(has_self_edges)
-        else:
-            raise ValueError(f"Unknown property name: {name}")
-    if len(rv) == 1:
-        return rv[0]
-    return rv
-
-
-def get_degrees(G, mask=None, *, L=None, U=None, has_self_edges=True):
-    if L is not None:
-        has_self_edges = G.nvals > 2 * L.nvals
-    elif U is not None:
-        has_self_edges = G.nvals > 2 * U.nvals
-    if has_self_edges:
-        if L is None or U is None:
-            L, U = get_properties(G, "L U", L=L, U=U)
-        degrees = (
-            L.reduce_rowwise("count").new(mask=mask) + U.reduce_rowwise("count").new(mask=mask)
-        ).new(name="degrees")
-    else:
-        degrees = G.reduce_rowwise("count").new(mask=mask, name="degrees")
-    return degrees
-
-
-def single_triangle_core(G, index, *, L=None, has_self_edges=True):
-    r = G[index, :].new()
-    has_self_edges = get_properties(G, "has_self_edges", L=L, has_self_edges=has_self_edges)
-    if has_self_edges:
-        # Pretty much all the time is spent here taking TRIL, which is used to ignore self-edges
-        L = get_properties(G, "L", L=L)
+def single_triangle_core(G, node):
+    index = G._key_to_id[node]
+    r = G._A[index, :].new()
+    # Pretty much all the time is spent here taking TRIL, which is used to ignore self-edges
+    L = G.get_property("L-")
+    if G.get_property("has_self_edges"):
         del r[index]  # Ignore self-edges
-        return plus_pair(L @ r).new(mask=r.S).reduce(allow_empty=False).value
-    else:
-        return plus_pair(G @ r).new(mask=r.S).reduce(allow_empty=False).value // 2
+    return plus_pair(L @ r).new(mask=r.S).reduce(allow_empty=False).value
 
 
-def triangles_core(G, mask=None, *, L=None, U=None):
+def triangles_core(G, mask=None):
     # Ignores self-edges
-    L, U = get_properties(G, "L U", L=L, U=U)
+    L, U = G.get_properties("L- U-")
     C = plus_pair(L @ L.T).new(mask=L.S)
     return (
         C.reduce_rowwise().new(mask=mask)
@@ -83,39 +31,38 @@ def triangles_core(G, mask=None, *, L=None, U=None):
 
 @not_implemented_for("directed")
 def triangles(G, nodes=None):
+    G = to_undirected_graph(G, dtype=bool)
     if len(G) == 0:
         return {}
-    A, key_to_id = graph_to_adjacency(G, dtype=bool)
     if nodes in G:
-        return single_triangle_core(A, key_to_id[nodes])
-    mask, id_to_key = list_to_mask(nodes, key_to_id)
-    result = triangles_core(A, mask=mask)
-    return vector_to_dict(result, key_to_id, id_to_key, mask=mask, fillvalue=0)
+        return single_triangle_core(G, nodes)
+    mask = G.list_to_mask(nodes)
+    result = triangles_core(G, mask=mask)
+    return G.vector_to_dict(result, mask=mask, fillvalue=0)
 
 
-def total_triangles_core(G, *, L=None, U=None):
+def total_triangles_core(G):
     # We use SandiaDot method, because it's usually the fastest on large graphs.
     # For smaller graphs, Sandia method is usually faster: plus_pair(L @ L).new(mask=L.S)
-    L, U = get_properties(G, "L U", L=L, U=U)
+    L, U = G.get_properties("L- U-")
     return plus_pair(L @ U.T).new(mask=L.S).reduce_scalar(allow_empty=False).value
 
 
-def transitivity_core(G, *, L=None, U=None, degrees=None):
-    L, U = get_properties(G, "L U", L=L, U=U)
-    numerator = total_triangles_core(G, L=L, U=U)
+def transitivity_core(G):
+    numerator = total_triangles_core(G)
     if numerator == 0:
         return 0
-    degrees = get_properties(G, "degrees", L=L, U=U, degrees=degrees)
+    degrees = G.get_property("degrees-")
     denom = (degrees * (degrees - 1)).reduce().value
     return 6 * numerator / denom
 
 
-def transitivity_directed_core(G, *, has_self_edges=True):
+def transitivity_directed_core(G):
     # XXX" is transitivity supposed to work on directed graphs like this?
-    if has_self_edges:
-        A = select.offdiag(G)
+    if G.get_property("has_self_edges"):
+        A = G.get_property("offdiag")
     else:
-        A = G
+        A = G._A
     numerator = plus_pair(A @ A.T).new(mask=A.S).reduce_scalar(allow_empty=False).value
     if numerator == 0:
         return 0
@@ -125,32 +72,28 @@ def transitivity_directed_core(G, *, has_self_edges=True):
 
 
 def transitivity(G):
+    G = to_graph(G, dtype=bool)  # directed or undirected
     if len(G) == 0:
         return 0
-    A = gb.io.from_networkx(G, weight=None, dtype=bool)
-    if isinstance(G, nx.DiGraph):
-        return transitivity_directed_core(A)
+    if G.is_directed():
+        return transitivity_directed_core(G)
     else:
-        return transitivity_core(A)
+        return transitivity_core(G)
 
 
-def clustering_core(G, mask=None, *, L=None, U=None, degrees=None):
-    L, U = get_properties(G, "L U", L=L, U=U)
-    tri = triangles_core(G, mask=mask, L=L, U=U)
-    degrees = get_degrees(G, mask=mask, L=L, U=U)
+def clustering_core(G, mask=None):
+    tri = triangles_core(G, mask=mask)
+    degrees = G.get_property("degrees-")
     denom = degrees * (degrees - 1)
     return (2 * tri / denom).new(name="clustering")
 
 
-def clustering_directed_core(G, mask=None, *, has_self_edges=True):
-    # TODO: Alright, this introduces us to properties of directed graphs:
-    # has_self_edges, offdiag, row_degrees, column_degrees, total_degrees, recip_degrees
-    # (in_degrees, out_degrees?)
-    if has_self_edges:
-        A = select.offdiag(G)
+def clustering_directed_core(G, mask=None):
+    if G.get_property("has_self_edges"):
+        A = G.get_property("offdiag")
     else:
-        A = G
-    AT = A.T.new()
+        A = G._A
+    AT = G.get_property("AT")
     temp = plus_pair(A @ A.T).new(mask=A.S)
     tri = (
         temp.reduce_rowwise().new(mask=mask)
@@ -165,27 +108,32 @@ def clustering_directed_core(G, mask=None, *, has_self_edges=True):
     return (tri / (total_degrees * (total_degrees - 1) - 2 * recip_degrees)).new(name="clustering")
 
 
-def single_clustering_core(G, index, *, L=None, degrees=None, has_self_edges=True):
-    has_self_edges = get_properties(G, "has_self_edges", L=L, has_self_edges=has_self_edges)
-    tri = single_triangle_core(G, index, L=L, has_self_edges=has_self_edges)
+def single_clustering_core(G, node):
+    tri = single_triangle_core(G, node)
     if tri == 0:
         return 0
-    if degrees is not None:
-        degrees = degrees[index].value
+    index = G._key_to_id[node]
+    if "degrees-" in G._cache:
+        degrees = G.get_property("degrees-")[index].value
+    elif "degrees+" in G._cache:
+        degrees = G.get_property("degrees+")[index].value
+        if G.get_property("has_self_edges") and G._A[index, index].value is not None:
+            degrees -= 1
     else:
-        row = G[index, :].new()
+        row = G._A[index, :].new()
         degrees = row.nvals
-        if has_self_edges and row[index].value is not None:
+        if G.get_property("has_self_edges") and row[index].value is not None:
             degrees -= 1
     denom = degrees * (degrees - 1)
     return 2 * tri / denom
 
 
-def single_clustering_directed_core(G, index, *, has_self_edges=True):
-    if has_self_edges:
-        A = select.offdiag(G)
+def single_clustering_directed_core(G, node, *, has_self_edges=True):
+    if G.get_property("has_self_edges"):
+        A = G.get_property("offdiag")
     else:
-        A = G
+        A = G._A
+    index = G._key_to_id[node]
     r = A[index, :].new()
     c = A[:, index].new()
     tri = (
@@ -202,27 +150,27 @@ def single_clustering_directed_core(G, index, *, has_self_edges=True):
 
 
 def clustering(G, nodes=None, weight=None):
-    if len(G) == 0:
-        return {}
     if weight is not None:
         # TODO: Not yet implemented.  Clustering implemented only for unweighted.
         return _nx_clustering(G, nodes=nodes, weight=weight)
-    A, key_to_id = graph_to_adjacency(G, weight=weight)
+    G = to_graph(G, weight=weight)  # to directed or undirected
+    if len(G) == 0:
+        return {}
     if nodes in G:
-        if isinstance(G, nx.DiGraph):
-            return single_clustering_directed_core(A, key_to_id[nodes])
+        if G.is_directed():
+            return single_clustering_directed_core(G, nodes)
         else:
-            return single_clustering_core(A, key_to_id[nodes])
-    mask, id_to_key = list_to_mask(nodes, key_to_id)
-    if isinstance(G, nx.DiGraph):
-        result = clustering_directed_core(A, mask=mask)
+            return single_clustering_core(G, nodes)
+    mask = G.list_to_mask(nodes)
+    if G.is_directed():
+        result = clustering_directed_core(G, mask=mask)
     else:
-        result = clustering_core(A, mask=mask)
-    return vector_to_dict(result, key_to_id, id_to_key, mask=mask, fillvalue=0.0)
+        result = clustering_core(G, mask=mask)
+    return G.vector_to_dict(result, mask=mask, fillvalue=0.0)
 
 
-def average_clustering_core(G, mask=None, count_zeros=True, *, L=None, U=None, degrees=None):
-    c = clustering_core(G, mask=mask, L=L, U=U, degrees=degrees)
+def average_clustering_core(G, mask=None, count_zeros=True):
+    c = clustering_core(G, mask=mask)
     val = c.reduce(allow_empty=False).value
     if not count_zeros:
         return val / c.nvals
@@ -232,8 +180,8 @@ def average_clustering_core(G, mask=None, count_zeros=True, *, L=None, U=None, d
         return val / c.size
 
 
-def average_clustering_directed_core(G, mask=None, count_zeros=True, *, has_self_edges=True):
-    c = clustering_directed_core(G, mask=mask, has_self_edges=has_self_edges)
+def average_clustering_directed_core(G, mask=None, count_zeros=True):
+    c = clustering_directed_core(G, mask=mask)
     val = c.reduce(allow_empty=False).value
     if not count_zeros:
         return val / c.nvals
@@ -244,14 +192,14 @@ def average_clustering_directed_core(G, mask=None, count_zeros=True, *, has_self
 
 
 def average_clustering(G, nodes=None, weight=None, count_zeros=True):
-    if len(G) == 0:
-        raise ZeroDivisionError()  # Not covered
     if weight is not None:
         # TODO: Not yet implemented.  Clustering implemented only for unweighted.
         return _nx_average_clustering(G, nodes=nodes, weight=weight, count_zeros=count_zeros)
-    A, key_to_id = graph_to_adjacency(G, weight=weight)
-    mask, _ = list_to_mask(nodes, key_to_id)
-    if isinstance(G, nx.DiGraph):
-        return average_clustering_directed_core(A, mask=mask, count_zeros=count_zeros)
+    G = to_graph(G, weight=weight)  # to directed or undirected
+    if len(G) == 0:
+        raise ZeroDivisionError()  # Not covered
+    mask = G.list_to_mask(nodes)
+    if G.is_directed():
+        return average_clustering_directed_core(G, mask=mask, count_zeros=count_zeros)
     else:
-        return average_clustering_core(A, mask=mask, count_zeros=count_zeros)
+        return average_clustering_core(G, mask=mask, count_zeros=count_zeros)

graphblas_algorithms/algorithms/link_analysis/pagerank_alg.py

@@ -4,11 +4,11 @@
 from graphblas import Vector, binary, unary
 from graphblas.semiring import plus_first, plus_times
 
-from graphblas_algorithms._utils import dict_to_vector, graph_to_adjacency, vector_to_dict
+from graphblas_algorithms.classes.digraph import to_graph
 
 
 def pagerank_core(
-    A,
+    G,
     alpha=0.85,
     personalization=None,
     max_iter=100,
@@ -18,6 +18,7 @@ def pagerank_core(
     row_degrees=None,
     name="pagerank",
 ):
+    A = G._A
     N = A.nrows
     if A.nvals == 0:
         return Vector(float, N, name=name)
@@ -116,20 +117,21 @@ def pagerank(
     dangling=None,
 ):
     warn("", DeprecationWarning, stacklevel=2)
+    G = to_graph(G, weight=weight, dtype=float)
     N = len(G)
     if N == 0:
         return {}
-    A, key_to_id = graph_to_adjacency(G, weight=weight, dtype=float)
     # We'll normalize initial, personalization, and dangling vectors later
-    x = dict_to_vector(nstart, key_to_id, dtype=float, name="nstart")
-    p = dict_to_vector(personalization, key_to_id, dtype=float, name="personalization")
-    row_degrees = A.reduce_rowwise().new(name="row_degrees")  # XXX: What about self-edges?
+    x = G.dict_to_vector(nstart, dtype=float, name="nstart")
+    p = G.dict_to_vector(personalization, dtype=float, name="personalization")
+    row_degrees = G._A.reduce_rowwise().new(name="row_degrees")  # XXX: What about self-edges?
+    # row_degrees = G.get_property('plus_rowwise+')  # Maybe?
     if dangling is not None and row_degrees.nvals < N:
-        dangling_weights = dict_to_vector(dangling, key_to_id, dtype=float, name="dangling")
+        dangling_weights = G.dict_to_vector(dangling, dtype=float, name="dangling")
     else:
         dangling_weights = None
     result = pagerank_core(
-        A,
+        G,
         alpha=alpha,
         personalization=p,
         max_iter=max_iter,
@@ -138,4 +140,4 @@ def pagerank(
         dangling=dangling_weights,
         row_degrees=row_degrees,
     )
-    return vector_to_dict(result, key_to_id, fillvalue=0.0)
+    return G.vector_to_dict(result, fillvalue=0.0)