networkx 0.1.1 → 0.2.0

data/lib/networkx/shortest_path/weighted.rb

@@ -1,19 +1,15 @@
-# 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|
+    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)
+  def self.help_multisource_dijkstra(graph, sources, weight, pred = nil, paths = nil, cutoff = nil, target = nil)
     count = ->(i) { i + 1 }
     i = -1
     dist = {}
@@ -26,17 +22,21 @@ module NetworkX
 
     until fringe.empty?
       d, _, v = fringe.pop
-      next if dist.key?(v)
+      next if dist.has_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)
+
+        if dist.has_key?(u)
           raise ValueError, 'Contradictory weights found!' if vu_dist < dist[u]
-        elsif !seen.key?(u) || vu_dist < seen[u]
+        elsif !seen.has_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?
@@ -50,7 +50,7 @@ module NetworkX
   end
 
   # Helper function for single source dijkstra
-  def self.help_dijkstra(graph, source, weight, pred=nil, paths=nil, cutoff=nil, target=nil)
+  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
 
@@ -62,15 +62,17 @@ module NetworkX
   # @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)
+  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)
+    raise KeyError, "No path to #{target}!" unless dist.has_key?(target)
+
     [dist[target], paths[target]]
   end
 
@@ -81,8 +83,9 @@ module NetworkX
   # @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)
+  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
@@ -94,7 +97,7 @@ module NetworkX
   # @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)
+  def self.multisource_dijkstra_path(graph, sources, cutoff = nil)
     _, path = multisource_dijkstra(graph, sources, nil, cutoff)
     path
   end
@@ -107,7 +110,7 @@ module NetworkX
   # @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)
+  def self.singlesource_dijkstra(graph, source, target = nil, cutoff = nil)
     multisource_dijkstra(graph, [source], target, cutoff)
   end
 
@@ -118,7 +121,7 @@ module NetworkX
   # @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)
+  def self.singlesource_dijkstra_path_length(graph, source, cutoff = nil)
     multisource_dijkstra_path_length(graph, [source], cutoff)
   end
 
@@ -129,7 +132,7 @@ module NetworkX
   # @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)
+  def self.singlesource_dijkstra_path(graph, source, cutoff = nil)
     multisource_dijkstra_path(graph, [source], cutoff)
   end
 
@@ -142,9 +145,11 @@ module NetworkX
   # @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)
+    raise KeyError, 'Node not reachable!' unless length.has_key?(target)
+
     length[target]
   end
 
@@ -168,7 +173,7 @@ module NetworkX
   #
   # @return [<Array<Hash{ Object => Array<Object> }, Hash{ Object => Numeric }>]
   #         predcessor hash and distance hash
-  def self.dijkstra_predecessor_distance(graph, source, cutoff=nil)
+  def self.dijkstra_predecessor_distance(graph, source, cutoff = nil)
     weight = get_weight(graph)
     pred = {source => []}
     [pred, help_dijkstra(graph, source, weight, pred, nil, cutoff)]
@@ -181,7 +186,7 @@ module NetworkX
   #
   # @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)
+  def self.all_pairs_dijkstra(graph, cutoff = nil)
     path = []
     graph.nodes.each_key { |n| path << [n, singlesource_dijkstra(graph, n, nil, cutoff)] }
     path
@@ -193,7 +198,7 @@ module NetworkX
   # @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)
+  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
@@ -205,16 +210,14 @@ module NetworkX
   # @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)
+  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)
+  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?
 
@@ -225,28 +228,31 @@ module NetworkX
       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]
+        elsif dist.has_key?(v) && dist_v == dist[v]
           pred[v] << u
         end
       end
     end
     unless paths.nil?
-      dsts = target.nil? ? pred : [target]
+      dsts = pred
       dsts.each_key do |dst|
         path, cur = [dst], dst
         until pred[cur][0].nil?
@@ -268,24 +274,28 @@ module NetworkX
   # @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)
+  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)
+  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)
+    raise ArgumentError, 'Node not reachable!' unless dist.has_key?(target)
+
     [dist[target], paths[target]]
   end
 
@@ -298,9 +308,11 @@ module NetworkX
   # @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 = help_bellman_ford(graph, [source], weight, nil, nil, nil, nil, target)
+    raise ArgumentError, 'Node not reachable!' unless length.has_key?(target)
+
     length[target]
   end
 
@@ -323,7 +335,7 @@ module NetworkX
   # @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)
+  def self.singlesource_bellmanford_path(graph, source, cutoff = nil)
     _, path = singlesource_bellmanford(graph, source, cutoff)
     path
   end
@@ -335,7 +347,7 @@ module NetworkX
   # @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)
+  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
@@ -346,7 +358,7 @@ module NetworkX
   # @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)
+  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
@@ -358,7 +370,7 @@ module NetworkX
   # @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)
+  def self.allpairs_bellmanford_path(graph, cutoff = nil)
     paths = []
     graph.nodes.each_key { |n| paths << [n, singlesource_bellmanford_path(graph, n, cutoff)] }
     paths
@@ -385,8 +397,6 @@ module NetworkX
     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
@@ -399,10 +409,9 @@ module NetworkX
       dist[n], pred[n] = 0, []
     end
     weight = get_weight(graph)
-    dist_bellman = help_bellman_ford(graph, sources, weight, pred, nil, dist=dist)
+    dist_bellman = help_bellman_ford(graph, sources, weight, pred, nil, 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
+    set_path_lengths_johnson(graph, dist_path, new_weight)
   end
 end

data/lib/networkx/to_matrix.rb

@@ -1,11 +1,10 @@
 module NetworkX
-  # TODO: Reduce condition branches and method length
-  def self.to_matrix(graph, val, multigraph_weight='sum')
+  def self.to_matrix(graph, val, multigraph_weight = 'sum')
     is_undirected = !graph.directed?
     is_multigraph = graph.multigraph?
     nodelen = graph.nodes.length
 
-    m = NMatrix.new(nodelen, val)
+    m = Matrix.build(nodelen) { val }
     index = {}
     inv_index = {}
     ind = 0

data/lib/networkx/traversals/bfs.rb

@@ -1,6 +1,4 @@
 module NetworkX
-  # TODO: Reduce method length
-
   # Returns edges of the graph travelled in breadth first fashion
   #
   # @example
@@ -10,6 +8,7 @@ module NetworkX
   # @param source [Object] node to start bfs from
   def self.bfs_edges(graph, source)
     raise KeyError, "There exists no node names #{source} in the given graph." unless graph.node?(source)
+
     bfs_edges = []
     visited = [source]
     queue = Queue.new.push([source, graph.neighbours(source)])
@@ -17,6 +16,7 @@ module NetworkX
       parent, children = queue.pop
       children.each_key do |child|
         next if visited.include?(child)
+
         bfs_edges << [parent, child]
         visited << child
         queue.push([child, graph.neighbours(child)])
@@ -55,4 +55,56 @@ module NetworkX
     bfs_edges.each { |u, v| predecessors[v] = u }
     predecessors
   end
+
+  class Graph
+    def bfs_nodes(root)
+      each_bfs_node(root).to_a
+    end
+
+    def each_bfs_node(root)
+      return enum_for(:each_bfs_node, root) unless block_given?
+
+      queue = [root]
+      dist = {root => 0}
+      while (v = queue.shift)
+        yield v
+        d = dist[v]
+        @adj[v].each do |u, _data|
+          next if dist[u]
+
+          dist[u] = d + 1
+          queue << u
+        end
+      end
+    end
+
+    # [EXPERIMENTAL]
+    #
+    # @param [Object] node which is root, start ,source
+    def bfs_edges(node)
+      each_bfs_edge(node).to_a
+    end
+
+    # [EXPERIMENTAL]
+    #
+    # @param [Object] node which is root, start ,source
+    def each_bfs_edge(node)
+      return enum_for(:each_bfs_edge, node) unless block_given?
+
+      que = [node]
+      used = {node => true}
+      while que[0]
+        node = que.shift
+
+        @adj[node].each do |v, _data|
+          next if used[v]
+
+          used[v] = true
+
+          yield(node, v)
+          que << v
+        end
+      end
+    end
+  end
 end

data/lib/networkx/traversals/dfs.rb

@@ -1,6 +1,4 @@
 module NetworkX
-  # TODO: Reduce method complexity and method length
-
   # Returns edges of the graph travelled in depth first fashion
   #
   # @example
@@ -9,8 +7,10 @@ module NetworkX
   # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
   # @param source [Object] node to start dfs from
   # @param depth_limit [Integer, nil] the depth limit of dfs
-  def self.dfs_edges(graph, source, depth_limit=nil)
+  def self.dfs_edges(graph, source, depth_limit = nil)
     raise KeyError, "There exists no node names #{source} in the given graph." unless graph.node?(source)
+
+    depth_limit += 1 if depth_limit
     depth_limit = graph.nodes.length if depth_limit.nil?
     dfs_edges = []
     visited = [source]
@@ -37,7 +37,7 @@ module NetworkX
   # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
   # @param source [Object] node to start dfs from
   # @param depth_limit [Integer, nil] the depth limit of dfs
-  def self.dfs_tree(graph, source, depth_limit=nil)
+  def self.dfs_tree(graph, source, depth_limit = nil)
     t = NetworkX::DiGraph.new
     t.add_node(source)
     t.add_edges_from(dfs_edges(graph, source, depth_limit))
@@ -52,7 +52,7 @@ module NetworkX
   # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
   # @param source [Object] node to start dfs from
   # @param depth_limit [Integer, nil] the depth limit of dfs
-  def self.dfs_successors(graph, source, depth_limit=nil)
+  def self.dfs_successors(graph, source, depth_limit = nil)
     dfs_edges = dfs_edges(graph, source, depth_limit)
     successors = {}
     dfs_edges.each do |u, v|
@@ -70,10 +70,66 @@ module NetworkX
   # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
   # @param source [Object] node to start dfs from
   # @param depth_limit [Integer, nil] the depth limit of dfs
-  def self.dfs_predecessors(graph, source, depth_limit=nil)
+  def self.dfs_predecessors(graph, source, depth_limit = nil)
     dfs_edges = dfs_edges(graph, source, depth_limit)
     predecessors = {}
     dfs_edges.each { |u, v| predecessors[v] = u }
     predecessors
   end
+
+  class Graph
+    # [EXPERIMENTAL]
+    #
+    # @param root [Object] node which is root, start, source
+    #
+    # @return [Array[Object]] nodes
+    def dfs_preorder_nodes(root)
+      each_dfs_preorder_node(root).to_a
+    end
+
+    # [EXPERIMENTAL]
+    #
+    # @param root [Object] node which is root, start, source
+    def each_dfs_preorder_node(root)
+      return enum_for(:each_dfs_preorder_node, root) unless block_given?
+
+      st = [root]
+      used = {root => true}
+      while st[-1]
+        node = st.pop
+        yield(node)
+        @adj[node].reverse_each do |v, _data|
+          next if used[v]
+
+          used[v] = node
+          st << v
+        end
+      end
+    end
+
+    # [EXPERIMENTAL]
+    #
+    # @param root [Object] node which is root, start, source
+    #
+    # @return [Array[Object]] array of dfs postorder nodes
+    def dfs_postorder_nodes(root, used = {root => true})
+      res = []
+      @adj[root].each do |v, _data|
+        next if used[v]
+
+        used[v] = true
+        res.concat dfs_postorder_nodes(v, used)
+      end
+
+      res << root
+      res
+    end
+
+    # @param root [Object] node which is root, start, source
+    def each_dfs_postorder_node(root, &block)
+      return enum_for(:each_dfs_postorder_node, root) unless block_given?
+
+      dfs_postorder_nodes(root).each(&block)
+    end
+  end
 end

data/lib/networkx/traversals/edge_dfs.rb

@@ -1,6 +1,4 @@
 module NetworkX
-  # TODO: Reduce method complexity and method length
-
   # Helper function for edge_dfs
   #
   # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
@@ -11,7 +9,7 @@ module NetworkX
     case graph.class.name
     when 'NetworkX::Graph', 'NetworkX::DiGraph'
       graph.adj[node].each do |v, _|
-        if graph.class.name == 'NetworkX::DiGraph' || visited[[v, node]].nil?
+        if graph.instance_of?(::NetworkX::DiGraph) || visited[[v, node]].nil?
           visited[[node, v]] = true
           edges << [node, v]
         end
@@ -19,7 +17,7 @@ module NetworkX
     else
       graph.adj[node].each do |v, uv_keys|
         uv_keys.each_key do |k|
-          if graph.class.name == 'NetworkX::MultiDiGraph' || visited[[v, node, k]].nil?
+          if graph.instance_of?(::NetworkX::MultiDiGraph) || visited[[v, node, k]].nil?
             visited[[node, v, k]] = true
             edges << [node, v, k]
           end
@@ -32,12 +30,11 @@ module NetworkX
   # Helper function of edge_dfs
   def self.edge_id(graph, edge)
     return edge if graph.directed?
-    return Set.new([edge, (edge[0..1].reverse + edge[2])]) if graph.multigraph?
+    return Set.new([edge, (edge[0..1].reverse << edge[2])]) if graph.multigraph?
+
     Set.new([edge, edge.reverse])
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Performs edge dfs on the graph
   # Orientation :ignore, directed edges can be
   #                     travelled in both fashions
@@ -49,15 +46,15 @@ module NetworkX
   #   NetworkX.edge_dfs(graph, source, 'ignore')
   #
   # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
-  # @param source [Object] node to start dfs from
+  # @param start [Object] node to start dfs from
   # @param orientation [:ignore, :reverse', nil] the orientation of edges of graph
-  def self.edge_dfs(graph, start, orientation=nil)
+  def self.edge_dfs(graph, start, orientation = nil)
     case orientation
     when :reverse
-      graph = graph.reverse if graph.class.name == 'NetworkX::DiGraph' || graph.class.name == 'NetworkX::MultiDiGraph'
+      graph = graph.reverse if graph.instance_of?(::NetworkX::DiGraph) || graph.instance_of?(::NetworkX::MultiDiGraph)
     when :ignore
-      graph = graph.to_undirected if graph.class.name == 'NetworkX::DiGraph'
-      graph = graph.to_multigraph if graph.class.name == 'NetworkX::MultiDiGraph'
+      graph = graph.to_undirected if graph.instance_of?(::NetworkX::DiGraph)
+      graph = graph.to_multigraph if graph.instance_of?(::NetworkX::MultiDiGraph)
     end
 
     visited_edges = []
@@ -87,4 +84,31 @@ module NetworkX
     end
     e.take(graph.number_of_edges)
   end
+
+  class Graph
+    def dfs_edges(node)
+      each_dfs_edge(node).to_a
+    end
+
+    def each_dfs_edge(node)
+      return enum_for(:each_dfs_edge, node) unless block_given?
+
+      st = [node]
+      used = {}
+      parents = {}
+      while st[-1]
+        node = st.pop
+
+        yield(parents[node], node) if parents[node]
+
+        used[node] = true
+        @adj[node].reverse_each do |v, _data|
+          next if used[v]
+
+          parents[v] = node
+          st << v unless used[v]
+        end
+      end
+    end
+  end
 end

data/lib/networkx/version.rb

@@ -1,3 +1,3 @@
 module NetworkX
-  VERSION = '0.1.1'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/lib/networkx.rb

@@ -1,5 +1,5 @@
 require 'set'
-require 'nmatrix'
+require 'matrix'
 require 'rb_heap'
 require 'securerandom'
 require_relative 'networkx/version'
@@ -35,3 +35,9 @@ require_relative 'networkx/auxillary_functions/wiener'
 require_relative 'networkx/auxillary_functions/cycles'
 require_relative 'networkx/link_analysis/hits'
 require_relative 'networkx/link_analysis/pagerank'
+require_relative 'networkx/others/bridges'
+require_relative 'networkx/others/generators'
+require_relative 'networkx/others/grid_2d_graph'
+require_relative 'networkx/others/info'
+require_relative 'networkx/others/number_connected_components'
+require_relative 'networkx/others/reads'

data/networkx.gemspec

@@ -20,19 +20,18 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.15'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'redcarpet'
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rspec-its'
-  spec.add_development_dependency 'rubocop', '>= 0.40.0'
-  spec.add_development_dependency 'rubocop-rspec'
-  spec.add_development_dependency 'rubygems-tasks'
-  spec.add_development_dependency 'saharspec'
-  spec.add_development_dependency 'simplecov'
-  spec.add_development_dependency 'yard'
-  spec.add_runtime_dependency 'nmatrix'
-  spec.add_runtime_dependency 'rb_heap'
+  spec.add_development_dependency 'rspec-its', '~> 1.0'
+  spec.add_development_dependency 'rubocop', '~> 1.0'
+  spec.add_development_dependency 'rubocop-rake', '~> 0.6'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.0'
+  spec.add_development_dependency 'rubygems-tasks', '~> 0.2'
+  spec.add_development_dependency 'saharspec', '~> 0.0'
+  spec.add_development_dependency 'simplecov', '~> 0.21'
+  spec.add_development_dependency 'yard', '~> 0.9'
 
-  spec.add_development_dependency 'guard-rspec' if RUBY_VERSION >= '2.2.5'
+  spec.add_runtime_dependency 'matrix', '~> 0.4'
+  spec.add_runtime_dependency 'rb_heap', '~> 1.0'
 end