ENH : adding parallel implementations of all_pairs_ algos

nx_parallel/algorithms/__init__.py

@@ -1,6 +1,7 @@
 # subpackages
 from .centrality import *
 from .shortest_paths import *
+from .approximation import *
 
 # modules
 from .efficiency_measures import *

nx_parallel/algorithms/approximation/__init__.py

@@ -0,0 +1 @@
+from .connectivity import *

nx_parallel/algorithms/approximation/connectivity.py

@@ -0,0 +1,51 @@
+"""Parallel implementations of fast approximation for node connectivity"""
+import itertools
+from joblib import Parallel, delayed
+import nx_parallel as nxp
+from networkx.algorithms.approximation.connectivity import local_node_connectivity
+
+__all__ = [
+    "all_pairs_node_connectivity",
+]
+
+
+def all_pairs_node_connectivity(G, nbunch=None, cutoff=None):
+    def _calculate_all_pairs_node_connectivity_subset(chunk):
+        for u, v in chunk:
+            k = local_node_connectivity(G, u, v, cutoff=cutoff)
+            all_pairs[u][v] = k
+            if not directed:
+                all_pairs[v][u] = k
+
+    if hasattr(G, "graph_object"):
+        G = G.graph_object
+
+    if nbunch is None:
+        nbunch = G
+    else:
+        nbunch = set(nbunch)
+
+    directed = G.is_directed()
+    if directed:
+        iter_func = itertools.permutations
+    else:
+        iter_func = itertools.combinations
+
+    pairs = list(iter_func(nbunch, 2))
+
+    all_pairs = {}
+    for u, v in pairs:
+        all_pairs.setdefault(u, {})[v] = None
+        if not directed:
+            all_pairs.setdefault(v, {})[u] = None
+
+    total_cores = nxp.cpu_count()
+    num_in_chunk = max(len(pairs) // total_cores, 1)
+    pair_chunks = nxp.chunks(pairs, num_in_chunk)
+
+    Parallel(n_jobs=total_cores, backend="threading")(
+        delayed(_calculate_all_pairs_node_connectivity_subset)(chunk)
+        for chunk in pair_chunks
+    )
+
+    return all_pairs

nx_parallel/algorithms/shortest_paths/__init__.py

@@ -1 +1,2 @@
 from .weighted import *
+from .unweighted import *

nx_parallel/algorithms/shortest_paths/unweighted.py

@@ -0,0 +1,49 @@
+# TODO : update docstrings
+
+"""
+Shortest path parallel algorithms for unweighted graphs.
+"""
+
+from joblib import Parallel, delayed
+import nx_parallel as nxp
+from networkx.algorithms.shortest_paths.unweighted import (
+    single_source_shortest_path_length,
+    single_source_shortest_path,
+)
+
+__all__ = [
+    "all_pairs_shortest_path",
+    "all_pairs_shortest_path_length",
+]
+
+
+def all_pairs_shortest_path_length(G, cutoff=None):
+    """Computes the shortest path lengths between all nodes in `G`."""
+    if hasattr(G, "graph_object"):
+        G = G.graph_object
+
+    length = single_source_shortest_path_length
+
+    def _calculate_all_pairs_shortest_path_length_subset(n):
+        return (n, (length(G, n, cutoff=cutoff)))
+
+    total_cores = nxp.cpu_count()
+
+    return Parallel(n_jobs=total_cores, return_as="generator")(
+        delayed(_calculate_all_pairs_shortest_path_length_subset)(n) for n in G
+    )
+
+
+def all_pairs_shortest_path(G, cutoff=None):
+    """Compute shortest paths between all nodes."""
+    if hasattr(G, "graph_object"):
+        G = G.graph_object
+
+    def _calculate_all_pairs_shortest_path_subset(n):
+        return (n, (single_source_shortest_path(G, n, cutoff=cutoff)))
+
+    total_cores = nxp.cpu_count()
+
+    return Parallel(n_jobs=total_cores, return_as="generator")(
+        delayed(_calculate_all_pairs_shortest_path_subset)(n) for n in G
+    )

nx_parallel/algorithms/shortest_paths/weighted.py

@@ -1,8 +1,87 @@
+# TODO : update docstrings
+
+"""
+Shortest path parallel algorithms for weighted graphs.
+"""
+
 from joblib import Parallel, delayed
-from networkx.algorithms.shortest_paths.weighted import single_source_bellman_ford_path
 import nx_parallel as nxp
+from networkx.algorithms.shortest_paths.weighted import (
+    single_source_dijkstra,
+    single_source_dijkstra_path_length,
+    single_source_dijkstra_path,
+    single_source_bellman_ford_path,
+    single_source_bellman_ford_path_length,
+)
+
+__all__ = [
+    "all_pairs_dijkstra",
+    "all_pairs_dijkstra_path_length",
+    "all_pairs_dijkstra_path",
+    "all_pairs_bellman_ford_path_length",
+    "all_pairs_bellman_ford_path",
+]
+
+
+def all_pairs_dijkstra(G, cutoff=None, weight="weight"):
+    """Find shortest weighted paths and lengths between all nodes."""
+
+    def _calculate_all_pairs_dijkstra_subset(n):
+        return (n, single_source_dijkstra(G, n, cutoff=cutoff, weight=weight))
+
+    if hasattr(G, "graph_object"):
+        G = G.graph_object
 
-__all__ = ["all_pairs_bellman_ford_path"]
+    return Parallel(n_jobs=-1, return_as="generator")(
+        delayed(_calculate_all_pairs_dijkstra_subset)(n) for n in G
+    )
+
+
+def all_pairs_dijkstra_path_length(G, cutoff=None, weight="weight"):
+    """Compute shortest path lengths between all nodes in a weighted graph."""
+    if hasattr(G, "graph_object"):
+        G = G.graph_object
+
+    length = single_source_dijkstra_path_length
+
+    def _calculate_all_pairs_dijkstra_path_length_subset(n):
+        return (n, length(G, n, cutoff=cutoff, weight=weight))
+
+    return Parallel(n_jobs=-1, return_as="generator")(
+        delayed(_calculate_all_pairs_dijkstra_path_length_subset)(n) for n in G
+    )
+
+
+def all_pairs_dijkstra_path(G, cutoff=None, weight="weight"):
+    """Compute shortest paths between all nodes in a weighted graph."""
+    if hasattr(G, "graph_object"):
+        G = G.graph_object
+
+    path = single_source_dijkstra_path
+
+    def _calculate_all_pairs_dijkstra_path_subset(n):
+        return (n, path(G, n, cutoff=cutoff, weight=weight))
+
+    return Parallel(n_jobs=-1, return_as="generator")(
+        delayed(_calculate_all_pairs_dijkstra_path_subset)(n) for n in G
+    )
+
+
+def all_pairs_bellman_ford_path_length(G, weight="weight"):
+    """Compute shortest path lengths between all nodes in a weighted graph."""
+
+    def _calculate_shortest_paths_length_subset(n):
+        return (n, length(G, n, weight=weight))
+
+    if hasattr(G, "graph_object"):
+        G = G.graph_object
+
+    length = single_source_bellman_ford_path_length
+
+    distance = Parallel(n_jobs=-1, return_as="generator")(
+        delayed(_calculate_shortest_paths_length_subset)(n) for n in G
+    )
+    return distance
 
 
 def all_pairs_bellman_ford_path(G, weight="weight"):

nx_parallel/interface.py

@@ -1,12 +1,25 @@
 from nx_parallel.algorithms.centrality.betweenness import betweenness_centrality
-from nx_parallel.algorithms.shortest_paths.weighted import all_pairs_bellman_ford_path
+from nx_parallel.algorithms.shortest_paths.weighted import (
+    all_pairs_dijkstra,
+    all_pairs_dijkstra_path_length,
+    all_pairs_dijkstra_path,
+    all_pairs_bellman_ford_path_length,
+    all_pairs_bellman_ford_path,
+)
+from nx_parallel.algorithms.shortest_paths.unweighted import (
+    all_pairs_shortest_path,
+    all_pairs_shortest_path_length,
+)
 from nx_parallel.algorithms.efficiency_measures import local_efficiency
 from nx_parallel.algorithms.isolate import number_of_isolates
 from nx_parallel.algorithms.tournament import (
     is_reachable,
     tournament_is_strongly_connected,
 )
 from nx_parallel.algorithms.vitality import closeness_vitality
+from nx_parallel.algorithms.approximation.connectivity import (
+    all_pairs_node_connectivity,
+)
 
 __all__ = ["Dispatcher", "ParallelGraph"]
 
@@ -46,9 +59,20 @@ class Dispatcher:
     # Efficiency
     local_efficiency = local_efficiency
 
-    # Shortest Paths : all pairs shortest paths(bellman_ford)
+    # Shortest Paths : weighted graphs
+    all_pairs_dijkstra = all_pairs_dijkstra
+    all_pairs_dijkstra_path_length = all_pairs_dijkstra_path_length
+    all_pairs_dijkstra_path = all_pairs_dijkstra_path
+    all_pairs_bellman_ford_path_length = all_pairs_bellman_ford_path_length
     all_pairs_bellman_ford_path = all_pairs_bellman_ford_path
 
+    # Shortest Paths : unweighted graphs
+    all_pairs_shortest_path = all_pairs_shortest_path
+    all_pairs_shortest_path_length = all_pairs_shortest_path_length
+
+    #
+    approximate_all_pairs_node_connectivity = all_pairs_node_connectivity
+
     # =============================
 
     @staticmethod