networkx 0.1.0 → 0.1.1

data/lib/networkx/operators/unary.rb

@@ -0,0 +1,17 @@
+module NetworkX
+  # Performs the complement operation on the graph
+  #
+  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph
+  #
+  # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the complement of the graph
+  def self.complement(graph)
+    result = Marshal.load(Marshal.dump(graph))
+    result.clear
+
+    result.add_nodes(graph.nodes.map { |u, attrs| [u, attrs] })
+    graph.adj.each do |u, u_edges|
+      graph.nodes.each { |v, attrs| result.add_edge(u, v, attrs) if !u_edges.key?(v) && u != v }
+    end
+    result
+  end
+end

data/lib/networkx/shortest_path/astar.rb

@@ -0,0 +1,71 @@
+module NetworkX
+  # TODO: Reduce method complexity and method length
+
+  # Returns path using astar algorithm between source and target
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] a node to start astar from
+  # @param target [Object] a node to end astar
+  # @param heuristic [] a lambda to compute heuristic b/w two nodes
+  #
+  # @return [Array<Object>] an array of nodes forming a path between source
+  #                         and target
+  def self.astar_path(graph, source, target, heuristic=nil)
+    warn 'A* is not implemented for MultiGraph and MultiDiGraph'
+    raise ArgumentError, 'Either source or target is not in graph' unless graph.node?(source) && graph.node?(target)
+    count = ->(i) { i + 1 }
+    i = -1
+    heuristic ||= (->(_u, _v) { 0 })
+    heap = Heap.new { |x, y| x[0] < y[0] || (x[0] == y[0] && x[1] < y[1]) }
+    heap << [0, count.call(i), source, 0, nil]
+    enqueued, explored = {}, {}
+
+    until heap.empty?
+      _, _, curnode, dist, parent = heap.pop
+      if curnode == target
+        path = [curnode]
+        node = parent
+        until node.nil?
+          path << node
+          node = explored[node]
+        end
+        path.reverse
+        return path
+      end
+
+      next if explored.key?(curnode)
+
+      explored[curnode] = parent
+
+      graph.adj[curnode].each do |u, attrs|
+        next if explored.key?(u)
+        ncost = dist + (attrs[:weight] || 1)
+        if enqueued.key?(u)
+          qcost, = enqueued[u]
+          next if qcost <= ncost
+        else
+          h = heuristic.call(u, target)
+          enqueued[u] = ncost, h
+          heap << [ncost + h, count.call(i), u, ncost, curnode]
+        end
+      end
+    end
+    raise ArgumentError, 'Target not reachable!'
+  end
+
+  # Returns astar path length b/w source and target
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] a node to start astar from
+  # @param target [Object] a node to end astar
+  # @param heuristic [] a lambda to compute heuristic b/w two nodes
+  #
+  # @return [Numeric] the length of the path
+  def self.astar_path_length(graph, source, target, heuristic=nil)
+    raise ArgumentError, 'Either source or target is not in graph' unless graph.node?(source) && graph.node?(target)
+    path = astar_path(graph, source, target, heuristic)
+    path_length = 0
+    (1..(path.length - 1)).each { |i| path_length += (graph.adj[path[i - 1]][path[i]][:weight] || 1) }
+    path_length
+  end
+end

data/lib/networkx/shortest_path/dense.rb

@@ -0,0 +1,31 @@
+module NetworkX
+  # TODO: Reduce method length and method complexity
+
+  # Returns the all pair distance between all the nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  #
+  # @return [Hash{ Object => { Object => { Numeric }}}] a hash containing distances
+  #                                                     b/w all pairs of nodes
+  def self.floyd_warshall(graph)
+    a, index = to_matrix(graph, Float::INFINITY, 'min')
+    nodelen = graph.nodes.length
+    (0..(nodelen - 1)).each { |i| a[i, i] = 0 }
+    (0..(nodelen - 1)).each do |k|
+      (0..(nodelen - 1)).each do |i|
+        (0..(nodelen - 1)).each do |j|
+          a[i, j] = [a[i, j], a[i, k] + a[k, j]].min
+        end
+      end
+    end
+
+    as_hash = {}
+    (0..(nodelen - 1)).each do |i|
+      (0..(nodelen - 1)).each do |j|
+        as_hash[index[i]] = {} unless as_hash.key?(index[i])
+        as_hash[index[i]][index[j]] = a[i, j]
+      end
+    end
+    as_hash
+  end
+end

data/lib/networkx/shortest_path/unweighted.rb

@@ -0,0 +1,139 @@
+module NetworkX
+  # TODO: Reduce method length
+
+  # Helper function for single source shortest path length
+  def self.help_single_shortest_path_length(adj, firstlevel, cutoff)
+    iterator = Enumerator.new do |e|
+      seen = {}
+      level = 0
+      nextlevel = firstlevel
+
+      while !nextlevel.empty? && cutoff >= level
+        thislevel = nextlevel
+        nextlevel = {}
+        thislevel.each do |u, _attrs|
+          next if seen.key?(u)
+          seen[u] = level
+          nextlevel.merge!(adj[u])
+          e.yield [u, level]
+        end
+        level += 1
+      end
+      seen.clear
+    end
+    iterator
+  end
+
+  # Computes shortest path values to all nodes from a given node
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source to compute path length from
+  # @param cutoff [Numeric, nil] cutoff for the shortest path algorithm
+  #
+  # @return [Array<Object, Numeric>] path lengths for all nodes
+  def self.single_source_shortest_path_length(graph, source, cutoff=nil)
+    raise ArgumentError, 'Source not found in the Graph!' unless graph.node?(source)
+    cutoff = Float::INFINITY if cutoff.nil?
+    nextlevel = {source => 1}
+    help_single_shortest_path_length(graph.adj, nextlevel, cutoff).take(graph.nodes.length)
+  end
+
+  # Computes shortest path values to all nodes from all nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param cutoff [Numeric, nil] cutoff for the shortest path algorithm
+  #
+  # @return [Array<Object, Array<Object, Numeric>>] path lengths for all nodes from all nodes
+  def self.all_pairs_shortest_path_length(graph, cutoff=nil)
+    shortest_paths = []
+    graph.nodes.each_key { |n| shortest_paths << [n, single_source_shortest_path_length(graph, n, cutoff)] }
+    shortest_paths
+  end
+
+  # TODO: Reduce method length
+
+  # Helper function for finding single source shortest path
+  def self.help_single_shortest_path(adj, firstlevel, paths, cutoff)
+    level = 0
+    nextlevel = firstlevel
+    while !nextlevel.empty? && cutoff > level
+      thislevel = nextlevel
+      nextlevel = {}
+      thislevel.each_key do |u|
+        adj[u].each_key do |v|
+          unless paths.key?(v)
+            paths[v] = paths[u] + [v]
+            nextlevel[v] = 1
+          end
+        end
+      end
+      level += 1
+    end
+    paths
+  end
+
+  # Computes single source shortest path from a node to every other node
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source from which shortest paths are needed
+  # @param cutoff [Numeric, nil] cutoff for the shortest path algorithm
+  #
+  # @return [Array<Object, Array<Object, Array<Object>>>] path lengths for all nodes from all nodes
+  def self.single_source_shortest_path(graph, source, cutoff=nil)
+    raise ArgumentError, 'Source not found in the Graph!' unless graph.node?(source)
+    cutoff = Float::INFINITY if cutoff.nil?
+    nextlevel = {source => 1}
+    paths = {source => [source]}
+    help_single_shortest_path(graph.adj, nextlevel, paths, cutoff)
+  end
+
+  # Computes shortest paths to all nodes from all nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param cutoff [Numeric, nil] cutoff for the shortest path algorithm
+  #
+  # @return [Array<Object, Hash {Object => Array<Object> }>] paths for all nodes from all nodes
+  def self.all_pairs_shortest_path(graph, cutoff=nil)
+    shortest_paths = []
+    graph.nodes.each_key { |n| shortest_paths << [n, single_source_shortest_path(graph, n, cutoff)] }
+    shortest_paths
+  end
+
+  # TODO: Reduce method length and method complexity
+
+  # Computes shortest paths to all nodes from all nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source for which predecessors are needed
+  # @param cutoff [Numeric, nil] cutoff for finding predecessor
+  # @param return_seen [Boolean] if true, returns seen dict
+  #
+  # @return [Array<Hash{ Object => Array<Object> }, Hash{ Object => Numeric }>,
+  #         Hash{ Object => Array<Object> }]
+  #         predecessors of a given node and/or seen dict
+  def self.predecessor(graph, source, cutoff=nil, return_seen=false)
+    raise ArgumentError, 'Source not found in the Graph!' unless graph.node?(source)
+    level = 0
+    nextlevel = [source]
+    seen = {source => level}
+    pred = {source => []}
+    until nextlevel.empty?
+      level += 1
+      thislevel = nextlevel
+      nextlevel = []
+      thislevel.each do |u|
+        graph.adj[u].each_key do |v|
+          if !seen.key?(v)
+            pred[v] = [u]
+            seen[v] = level
+            nextlevel << v
+          elsif seen[v] == level
+            pred[v] << u
+          end
+        end
+      end
+      break if cutoff.nil? && cutoff <= level
+    end
+    return_seen ? [pred, seen] : pred
+  end
+end

data/lib/networkx/shortest_path/weighted.rb

@@ -0,0 +1,408 @@
+# TODO: Reduce module length
+
+module NetworkX
+  # Helper function to extract weight from a adjecency hash
+  def self.get_weight(graph)
+    weight_get = lambda do |_, _, attrs|
+      return attrs[:weight] || 1 unless graph.multigraph?
+      attrs.group_by { |_k, vals| vals[:weight] || 1 }.keys.max
+    end
+    weight_get
+  end
+
+  # TODO: Reduce method length and method complexity
+
+  # Helper function for multisource dijkstra
+  def self.help_multisource_dijkstra(graph, sources, weight, pred=nil, paths=nil, cutoff=nil, target=nil)
+    count = ->(i) { i + 1 }
+    i = -1
+    dist = {}
+    seen = {}
+    fringe = Heap.new { |x, y| x[0] < y[0] || (x[0] == y[0] && x[1] < y[1]) }
+    sources.each do |s|
+      seen[s] = 0
+      fringe << [0, count.call(i), s]
+    end
+
+    until fringe.empty?
+      d, _, v = fringe.pop
+      next if dist.key?(v)
+      dist[v] = d
+      break if v == target
+      graph.adj[v].each do |u, attrs|
+        cost = weight.call(v, u, attrs)
+        next if cost.nil?
+        vu_dist = dist[v] + cost
+        next if !cutoff.nil? && vu_dist > cutoff
+        if dist.key?(u)
+          raise ValueError, 'Contradictory weights found!' if vu_dist < dist[u]
+        elsif !seen.key?(u) || vu_dist < seen[u]
+          seen[u] = vu_dist
+          fringe << [vu_dist, count.call(i), u]
+          paths[u] = paths[v] + [u] unless paths.nil?
+          pred[u] = [v] unless pred.nil?
+        elsif vu_dist == seen[u]
+          pred[u] << v unless pred.nil?
+        end
+      end
+    end
+    dist
+  end
+
+  # Helper function for single source dijkstra
+  def self.help_dijkstra(graph, source, weight, pred=nil, paths=nil, cutoff=nil, target=nil)
+    help_multisource_dijkstra(graph, [source], weight, pred, paths, cutoff, target)
+  end
+
+  # Computes shortest paths and path lengths to a target from one of the nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param sources [Array<Object>] Array of sources
+  # @param target [Object, nil] target node for the dijkstra algorithm
+  # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
+  #
+  # @return [Numeric, Array<Object>] path lengths for all nodes
+  def self.multisource_dijkstra(graph, sources, target=nil, cutoff=nil)
+    raise ValueError, 'Sources cannot be empty' if sources.empty?
+    return [0, [target]] if sources.include?(target)
+    paths = {}
+    weight = get_weight(graph)
+    sources.each { |source| paths[source] = [source] }
+    dist = help_multisource_dijkstra(graph, sources, weight, nil, paths, cutoff, target)
+    return [dist, paths] if target.nil?
+    raise KeyError, "No path to #{target}!" unless dist.key?(target)
+    [dist[target], paths[target]]
+  end
+
+  # Computes shortest path lengths to any from the given nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param sources [Array<Object>] Array of sources
+  # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
+  #
+  # @return [Hash{ Object => Numeric }] path lengths for any nodes from given nodes
+  def self.multisource_dijkstra_path_length(graph, sources, cutoff=nil)
+    raise ValueError, 'Sources cannot be empty' if sources.empty?
+    weight = get_weight(graph)
+    help_multisource_dijkstra(graph, sources, weight, nil, nil, cutoff)
+  end
+
+  # Computes shortest paths to any from the given nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param sources [Array<Object>] Array of sources
+  # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
+  #
+  # @return [Hash{ Object => Array<Object> }] paths for any nodes from given nodes
+  def self.multisource_dijkstra_path(graph, sources, cutoff=nil)
+    _, path = multisource_dijkstra(graph, sources, nil, cutoff)
+    path
+  end
+
+  # Computes shortest paths and path distances to all nodes/target from the given node
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source
+  # @param target [Object] target
+  # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
+  #
+  # @return [Hash{ Object => Array<Object> }, Array<Object>] paths for all nodes/target node from given node
+  def self.singlesource_dijkstra(graph, source, target=nil, cutoff=nil)
+    multisource_dijkstra(graph, [source], target, cutoff)
+  end
+
+  # Computes shortest path lengths to all nodes from the given node
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source
+  # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
+  #
+  # @return [Hash{ Object => Numeric }] path lengths for all nodes from given node
+  def self.singlesource_dijkstra_path_length(graph, source, cutoff=nil)
+    multisource_dijkstra_path_length(graph, [source], cutoff)
+  end
+
+  # Computes shortest paths to all nodes from the given node
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source
+  # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
+  #
+  # @return [Hash{ Object => Array<Object> }] paths for all nodes from given node
+  def self.singlesource_dijkstra_path(graph, source, cutoff=nil)
+    multisource_dijkstra_path(graph, [source], cutoff)
+  end
+
+  # Computes shortest path length to target from the given node
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source
+  # @param target [Object] target
+  #
+  # @return [Numeric] path length for target node from given node
+  def self.dijkstra_path_length(graph, source, target)
+    return 0 if source == target
+    weight = get_weight(graph)
+    length = help_dijkstra(graph, source, weight, nil, nil, nil, target)
+    raise KeyError, 'Node not reachable!' unless length.key?(target)
+    length[target]
+  end
+
+  # Computes shortest path to target from the given node
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source
+  # @param target [Object] target
+  #
+  # @return [Numeric] path for target node from given node
+  def self.dijkstra_path(graph, source, target)
+    _, path = singlesource_dijkstra(graph, source, target)
+    path
+  end
+
+  # Computes weighted shortest path length and predecessors
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source
+  # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
+  #
+  # @return [<Array<Hash{ Object => Array<Object> }, Hash{ Object => Numeric }>]
+  #         predcessor hash and distance hash
+  def self.dijkstra_predecessor_distance(graph, source, cutoff=nil)
+    weight = get_weight(graph)
+    pred = {source => []}
+    [pred, help_dijkstra(graph, source, weight, pred, nil, cutoff)]
+  end
+
+  # Finds shortest weighted paths and lengths between all nodes
+  #
+  # @param graph [Graph, DiGrhelp_dijkaph, MultiGraph, MultiDiGraph] a graph
+  # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
+  #
+  # @return [Array<Object, Array<Hash{ Object => Numeric }, Hash{ Object => Array<Object> }>>]
+  #          paths and path lengths between all nodes
+  def self.all_pairs_dijkstra(graph, cutoff=nil)
+    path = []
+    graph.nodes.each_key { |n| path << [n, singlesource_dijkstra(graph, n, nil, cutoff)] }
+    path
+  end
+
+  # Finds shortest weighted path length between all nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
+  #
+  # @return [Array<Object, Hash{ Object => Numeric }>] path lengths between all nodes
+  def self.all_pairs_dijkstra_path_length(graph, cutoff=nil)
+    path_lengths = []
+    graph.nodes.each_key { |n| path_lengths << [n, singlesource_dijkstra_path_length(graph, n, cutoff)] }
+    path_lengths
+  end
+
+  # Finds shortest weighted paths between all nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
+  #
+  # @return [Array<Object, Hash{ Object => Array<Object> }>] path lengths between all nodes
+  def self.all_pairs_dijkstra_path(graph, cutoff=nil)
+    paths = []
+    graph.nodes.each_key { |n| paths << singlesource_dijkstra_path(graph, n, cutoff) }
+    paths
+  end
+
+  # TODO: Reduce method length and method complexity
+
+  # Helper function for bellman ford
+  def self.help_bellman_ford(graph, sources, weight, pred=nil, paths=nil, dist=nil, cutoff=nil, target=nil)
+    pred = sources.product([[]]).to_h if pred.nil?
+    dist = sources.product([0]).to_h if dist.nil?
+
+    inf, n, count, q, in_q = Float::INFINITY, graph.nodes.length, {}, sources.clone, Set.new(sources)
+    until q.empty?
+      u = q.shift
+      in_q.delete(u)
+      skip = false
+      pred[u].each { |k| skip = true if in_q.include?(k) }
+      next if skip
+      dist_u = dist[u]
+      graph.adj[u].each do |v, e|
+        dist_v = dist_u + weight.call(u, v, e)
+        next if !cutoff.nil? && dist_v > cutoff
+        next if !target.nil? && dist_v > (dist[target] || inf)
+        if dist_v < (dist[v] || inf)
+          unless in_q.include?(v)
+            q << v
+            in_q.add(v)
+            count_v = (count[v] || 0) + 1
+            raise ArgumentError, 'Negative edge cycle detected!' if count_v == n
+            count[v] = count_v
+          end
+          dist[v] = dist_v
+          pred[v] = [u]
+        elsif dist.key?(v) && dist_v == dist[v]
+          pred[v] << u
+        end
+      end
+    end
+    unless paths.nil?
+      dsts = target.nil? ? pred : [target]
+      dsts.each_key do |dst|
+        path, cur = [dst], dst
+        until pred[cur][0].nil?
+          cur = pred[cur][0]
+          path << cur
+        end
+        path.reverse
+        paths[dst] = path
+      end
+    end
+    dist
+  end
+
+  # Finds shortest weighted path lengths and predecessors on shortest paths
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source
+  # @param target [Object, nil] target
+  # @param cutoff [Numeric, nil] cutoff for the dijkstra algorithm
+  #
+  # @return [Array<Hash{ Object => Array<Object> }, Hash{ Object => Numeric }>] predecessors and distances
+  def self.bellmanford_predecesor_distance(graph, source, target=nil, cutoff=nil)
+    raise ArgumentError, 'Node not found!' unless graph.node?(source)
+    weight = get_weight(graph)
+    # TODO: Detection of selfloop edges
+    dist = {source => 0}
+    pred = {source => []}
+    return [pred, dist] if graph.nodes.length == 1
+    dist = help_bellman_ford(graph, [source], weight, pred, nil, dist, cutoff, target)
+    [pred, dist]
+  end
+
+  def self.singlesource_bellmanford(graph, source, target=nil, cutoff=nil)
+    return [0, [source]] if source == target
+    weight = get_weight(graph)
+    paths = {source => [source]}
+    dist = help_bellman_ford(graph, [source], weight, nil, paths, nil, cutoff, target)
+    return [dist, paths] if target.nil?
+    raise ArgumentError, 'Node not reachable!' unless dist.key?(target)
+    [dist[target], paths[target]]
+  end
+
+  # Length of shortest path from source to target using Bellman Ford algorithm
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source
+  # @param target [Object] target
+  #
+  # @return [Numeric] distance between source and target
+  def self.bellmanford_path_length(graph, source, target)
+    return 0 if source == target
+    weight = get_weight(graph)
+    length = help_bellman_ford(graph, [source], weight, nil, nil, nil, nil, target=target)
+    raise ArgumentError, 'Node not reachable!' unless length.key?(target)
+    length[target]
+  end
+
+  # Shortest path from source to target using Bellman Ford algorithm
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source
+  # @param target [Object] target
+  #
+  # @return [Array<Object>] path from source to target
+  def self.bellmanford_path(graph, source, target)
+    _, path = singlesource_bellmanford(graph, source, target)
+    path
+  end
+
+  # Shortest path from source to all nodes using Bellman Ford algorithm
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source
+  # @param cutoff [Numeric, nil] cutoff for Bellman Ford algorithm
+  #
+  # @return [Hash{ Object => Array<Object> }] path from source to all nodes
+  def self.singlesource_bellmanford_path(graph, source, cutoff=nil)
+    _, path = singlesource_bellmanford(graph, source, cutoff)
+    path
+  end
+
+  # Shortest path length from source to all nodes using Bellman Ford algorithm
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source
+  # @param cutoff [Numeric, nil] cutoff for Bellman Ford algorithm
+  #
+  # @return [Hash{ Object => Numeric }] path lengths from source to all nodes
+  def self.singlesource_bellmanford_path_length(graph, source, cutoff=nil)
+    weight = get_weight(graph)
+    help_bellman_ford(graph, [source], weight, nil, nil, nil, cutoff)
+  end
+
+  # Shortest path lengths between all nodes using Bellman Ford algorithm
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param cutoff [Numeric, nil] cutoff for Bellman Ford algorithm
+  #
+  # @return [Array<Object, Hash{ Object => Numeric }>] path lengths from source to all nodes
+  def self.allpairs_bellmanford_path_length(graph, cutoff=nil)
+    path_lengths = []
+    graph.nodes.each_key { |n| path_lengths << [n, singlesource_bellmanford_path_length(graph, n, cutoff)] }
+    path_lengths
+  end
+
+  # Shortest paths between all nodes using Bellman Ford algorithm
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param cutoff [Numeric, nil] cutoff for Bellman Ford algorithm
+  #
+  # @return [Array<Object, Hash{ Object => Array<Object> }>] path lengths from source to all nodes
+  def self.allpairs_bellmanford_path(graph, cutoff=nil)
+    paths = []
+    graph.nodes.each_key { |n| paths << [n, singlesource_bellmanford_path(graph, n, cutoff)] }
+    paths
+  end
+
+  # Helper function to get sources
+  def self.get_sources(graph)
+    graph.nodes.collect { |k, _v| k }
+  end
+
+  # Helper function to get distances
+  def self.dist_path_lambda(_graph, _new_weight)
+    lambda do |graph, v, new_weight|
+      paths = {v => [v]}
+      _ = help_dijkstra(graph, v, new_weight, nil, paths)
+      paths
+    end
+  end
+
+  # Helper function to set path lengths for Johnson algorithm
+  def self.set_path_lengths_johnson(graph, dist_path, new_weight)
+    path_lengths = []
+    graph.nodes.each_key { |n| path_lengths << [n, dist_path.call(graph, n, new_weight)] }
+    path_lengths
+  end
+
+  # TODO: Reduce method length and method complexity
+
+  # Returns shortest path between all pairs of nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  #
+  # @return [Array<Object, Hash { Object => Array<Object> }] shortest paths between all pairs of nodes
+  def self.johnson(graph)
+    dist, pred = {}, {}
+    sources = get_sources(graph)
+    graph.nodes.each_key do |n|
+      dist[n], pred[n] = 0, []
+    end
+    weight = get_weight(graph)
+    dist_bellman = help_bellman_ford(graph, sources, weight, pred, nil, dist=dist)
+    new_weight = ->(u, v, d) { weight.call(u, v, d) + dist_bellman[u] - dist_bellman[v] }
+    dist_path = dist_path_lambda(graph, new_weight)
+    path_lengths = set_path_lengths_johnson(graph, dist_path, new_weight)
+    path_lengths
+  end
+end