parallel implementation for all_pairs_bellman_ford_path

nx_parallel/algorithms/shortest_paths/__init__.py

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

nx_parallel/algorithms/shortest_paths/weighted.py

@@ -0,0 +1,61 @@
+from joblib import Parallel, delayed
+from networkx.algorithms.shortest_paths.weighted import (
+    single_source_bellman_ford_path
+)
+
+import nx_parallel as nxp
+
+__all__ = ["all_pairs_bellman_ford_path"]
+
+
+def all_pairs_bellman_ford_path(G, weight="weight"):
+    """Compute shortest paths between all nodes in a weighted graph.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight : string or function (default="weight")
+        If this is a string, then edge weights will be accessed via the
+        edge attribute with this key (that is, the weight of the edge
+        joining `u` to `v` will be ``G.edges[u, v][weight]``). If no
+        such edge attribute exists, the weight of the edge is assumed to
+        be one.
+
+        If this is a function, the weight of an edge is the value
+        returned by the function. The function must accept exactly three
+        positional arguments: the two endpoints of an edge and the
+        dictionary of edge attributes for that edge. The function must
+        return a number.
+
+    Returns
+    -------
+    paths : iterator
+        (source, dictionary) iterator with dictionary keyed by target and
+        shortest path as the key value.
+
+    Notes
+    -----
+    Edge weight attributes must be numerical.
+    Distances are calculated as sums of weighted edges traversed.
+
+    """
+    def _calculate_shortest_paths_subset(G, source, weight):
+        return (source, single_source_bellman_ford_path(G, source, weight=weight))
+
+    if hasattr(G, "graph_object"):
+        G = G.graph_object
+
+    nodes = G.nodes
+
+    total_cores = nxp.cpu_count()
+
+    paths = Parallel(n_jobs=total_cores, return_as="generator")(
+                    delayed(_calculate_shortest_paths_subset)(
+                        G, 
+                        source, 
+                        weight=weight
+                    )
+                    for source in nodes
+                )
+    return paths

nx_parallel/interface.py

@@ -1,4 +1,5 @@
 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.efficiency_measures import (
     local_efficiency,
 )
@@ -43,6 +44,9 @@ class Dispatcher:
     # Efficiency
     local_efficiency = local_efficiency
 
+    # Shortest Paths : all pairs shortest paths(bellman_ford)
+    all_pairs_bellman_ford_path = all_pairs_bellman_ford_path
+
     # =============================
 
     @staticmethod

timing/timing_comparison.md

@@ -27,3 +27,6 @@ local_efficiency
 
 tournament is_reachable
 ![alt text](heatmap_is_reachable_timing.png)
+
+all_pairs_bellman_ford_path
+![alt text](heatmap_all_pairs_bellman_ford_path_timing.png)

timing/timing_individual_function.py

@@ -1,4 +1,6 @@
 import time
+import random
+import types
 
 import networkx as nx
 import pandas as pd
@@ -11,23 +13,30 @@
 heatmapDF = pd.DataFrame()
 number_of_nodes_list = [10, 50, 100, 300, 500]
 pList = [1, 0.8, 0.6, 0.4, 0.2]
-currFun = nx.betweenness_centrality
+currFun = nx.all_pairs_bellman_ford_path
 for i in range(0, len(pList)):
     p = pList[i]
     for j in range(0, len(number_of_nodes_list)):
         num = number_of_nodes_list[j]
-
+        
         # create original and parallel graphs
         G = nx.fast_gnp_random_graph(num, p, directed=False)
+
+        # for weighted graphs
+        for u, v in G.edges():
+            G[u][v]['weight'] = random.random()
+
         H = nx_parallel.ParallelGraph(G)
 
         # time both versions and update heatmapDF
         t1 = time.time()
         c = currFun(H)
+        if type(c)==types.GeneratorType: d = dict(c) 
         t2 = time.time()
         parallelTime = t2 - t1
         t1 = time.time()
         c = currFun(G)
+        if type(c)==types.GeneratorType: d = dict(c) 
         t2 = time.time()
         stdTime = t2 - t1
         timesFaster = stdTime / parallelTime