networkx 0.1.1 → 0.3.0

data/lib/networkx/auxillary_functions/union_find.rb

@@ -1,24 +1,104 @@
 module NetworkX
+  # Union Find Tree
+  #
+  # Reference
+  # - [ac-library-rb DSU (CC0)](https://github.com/universato/ac-library-rb/blob/main/lib/dsu.rb)
+  # - [Python NetworkX UnionFind](https://networkx.org/documentation/stable/_modules/networkx/utils/union_find.html)
+  #
+  #
+  # @attr_reader parents [Hash{ Object => Object }] Return parent of each element
+  # @attr_reader weights [Hash{ Object => Integer }] Return weight of each element
   class UnionFind
-    def initialize(nodes)
-      @unions = {}
-      nodes.each_with_index do |node, index|
-        @unions[node] = index
+    attr_accessor :parents, :weights
+
+    # Constructor for initializing Union Find Tree
+    #
+    # @param nodes [?Array[Object]] nodes
+    #
+    # @return [UnionFind] Union Find Tree
+    def initialize(nodes = nil)
+      @weights = {}
+      @parents = {}
+      nodes&.each do |node|
+        @weights[node] = 1
+        @parents[node] = node
+      end
+    end
+
+    # Return the root of node
+    #
+    # @param node [Object] node
+    #
+    # @return [Object] root of node, leader of node
+    def [](node)
+      if @parents.has_key?(node)
+        @parents[node] == node ? node : (@parents[node] = self[@parents[node]])
+      else
+        @weights[node] = 1
+        @parents[node] = node
       end
     end
 
-    def connected?(node_1, node_2)
-      @unions[node_1] == @unions[node_2]
+    # Return the root of node
+    #
+    # @param node [Object] node
+    #
+    # @return [Object] root of node, leader of node
+    def root(node)
+      @parents.has_key?(node) or raise ArgumentError.new, "#{node} is not a node"
+
+      @parents[node] == node ? node : (@parents[node] = root(@parents[node]))
+    end
+
+    def each(&block)
+      @parents.each_key(&block)
     end
 
-    def union(node_1, node_2)
-      return if connected?(node_1, node_2)
-      node1_id = @unions[node_1]
-      node2_id = @unions[node_2]
+    def to_sets
+      each.group_by { |node| root(node) }.values
+    end
+    alias groups to_sets
 
-      @unions.each do |node, id|
-        @unions[node] = node1_id if id == node2_id
+    # Is each root of two nodes the same?
+    #
+    # @param node1 [Object] node
+    # @param node2 [Object] node
+    #
+    # @return [bool] Is each root of node1 and nodes_2 the same?
+    def connected?(node1, node2)
+      root(node1) == root(node2)
+    end
+    alias same? connected?
+
+    # Unite nodes.
+    #
+    # @param nodes [Array[Object]] nodes
+    #
+    # @return [Object | nil] root of united nodes
+    def union(*nodes)
+      return merge(*nodes) if nodes.size == 2
+
+      roots = nodes.map { |node| self[node] }.uniq
+      return if roots.size == 1
+
+      roots.sort_by! { |root| @weights[root] }
+      root = roots[-1]
+      roots[0...-1].each do |r|
+        @weights[root] += @weights[r]
+        @parents[r] = root
       end
+      root
+    end
+    alias unite union
+
+    def merge(node1, node2)
+      x = self[node1]
+      y = self[node2]
+      return if x == y
+
+      x, y = y, x if @weights[x] < @weights[y]
+      @weights[x] += @weights[y]
+      @parents[y] = x
     end
   end
 end

data/lib/networkx/auxillary_functions/wiener.rb

@@ -7,7 +7,7 @@ module NetworkX
   def self.wiener_index(graph)
     total = all_pairs_shortest_path_length(graph)
     wiener_ind = 0
-    Hash[total].each { |_, distances| Hash[distances].each { |_, val| wiener_ind += val } }
+    total.to_h.each { |_, distances| distances.to_h.each { |_, val| wiener_ind += val } }
     graph.directed? ? wiener_ind : wiener_ind / 2
   end
 end

data/lib/networkx/converters/to_csv.rb

@@ -1,11 +1,9 @@
 module NetworkX
-  # TODO: Reduce method length and method complexity
-
   # Saves the graph in a csv file
   #
   # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
   # @param filename [String] filename of the graph
-  def self.graph_to_csv(graph, filename='graph.csv')
+  def self.graph_to_csv(graph, filename = 'graph.csv')
     CSV.open(filename, 'wb') do |csv|
       csv << [graph.class.name]
       csv << ['graph_values']

data/lib/networkx/converters/to_json.rb

@@ -13,8 +13,6 @@ module NetworkX
     json_hash.to_json
   end
 
-  # TODO: Reduce method length
-
   # Returns a graph from the json encoded graph
   #
   # @param json_str [JSON] json encoded string

data/lib/networkx/digraph.rb

@@ -8,7 +8,7 @@ module NetworkX
   # @attr_reader nodes [Hash{ Object => Hash{ Object => Object } }] Stores the nodes and their attributes
   # @attr_reader graph [Hash{ Object => Object }] Stores the attributes of the graph
   class DiGraph < Graph
-    attr_reader :adj, :nodes, :graph, :pred
+    attr_reader :adj, :graph, :pred
 
     # Constructor for initializing graph
     #
@@ -17,7 +17,7 @@ module NetworkX
     #
     # @param graph_attrs [Hash{ Object => Object }] the graph attributes in a hash format
     def initialize(**graph_attrs)
-      super(graph_attrs)
+      super(**graph_attrs)
 
       @pred = {}
     end
@@ -30,16 +30,16 @@ module NetworkX
     # @example Add an edge with no attribute
     #   graph.add_edge("Bangalore", "Chennai")
     #
-    # @param node_1 [Object] the first node of the edge
-    # @param node_2 [Object] the second node of the edge
+    # @param node1 [Object] the first node of the edge
+    # @param node2 [Object] the second node of the edge
     # @param edge_attrs [Hash{ Object => Object }] the hash of the edge attributes
-    def add_edge(node_1, node_2, **edge_attrs)
-      add_node(node_1)
-      add_node(node_2)
+    def add_edge(node1, node2, **edge_attrs)
+      add_node(node1)
+      add_node(node2)
 
-      edge_attrs = (@adj[node_1][node_2] || {}).merge(edge_attrs)
-      @adj[node_1][node_2] = edge_attrs
-      @pred[node_2][node_1] = edge_attrs
+      edge_attrs = (@adj[node1][node2] || {}).merge(edge_attrs)
+      @adj[node1][node2] = edge_attrs
+      @pred[node2][node1] = edge_attrs
     end
 
     # Adds a node and its attributes to the graph
@@ -50,9 +50,13 @@ module NetworkX
     # @param node [Object] the node object
     # @param node_attrs [Hash{ Object => Object }] the hash of the attributes of the node
     def add_node(node, **node_attrs)
-      super(node, node_attrs)
+      super(node, **node_attrs)
 
-      @pred[node] = {} unless @pred.key?(node)
+      @pred[node] = {} unless @pred.has_key?(node)
+    end
+
+    def nodes(data: true)
+      data ? @nodes : @nodes.keys
     end
 
     # Removes node from the graph
@@ -62,7 +66,7 @@ module NetworkX
     #
     # @param node [Object] the node to be removed
     def remove_node(node)
-      raise KeyError, "Error in deleting node #{node} from Graph." unless @nodes.key?(node)
+      raise KeyError, "Error in deleting node #{node} from Graph." unless @nodes.has_key?(node)
 
       neighbours = @adj[node]
       neighbours.each_key { |k| @pred[k].delete(node) }
@@ -80,15 +84,15 @@ module NetworkX
     # @example
     #   graph.remove_edge('Noida', 'Bangalore')
     #
-    # @param node_1 [Object] the first node of the edge
-    # @param node_2 [Object] the second node of the edge
-    def remove_edge(node_1, node_2)
-      raise KeyError, "#{node_1} is not a valid node." unless @nodes.key?(node_1)
-      raise KeyError, "#{node_2} is not a valid node" unless @nodes.key?(node_2)
-      raise KeyError, 'The given edge is not a valid one.' unless @adj[node_1].key?(node_2)
+    # @param node1 [Object] the first node of the edge
+    # @param node2 [Object] the second node of the edge
+    def remove_edge(node1, node2)
+      raise KeyError, "#{node1} is not a valid node." unless @nodes.has_key?(node1)
+      raise KeyError, "#{node2} is not a valid node" unless @nodes.has_key?(node2)
+      raise KeyError, 'The given edge is not a valid one.' unless @adj[node1].has_key?(node2)
 
-      @adj[node_1].delete(node_2)
-      @pred[node_2].delete(node_1)
+      @adj[node1].delete(node2)
+      @pred[node2].delete(node1)
     end
 
     # Clears the graph
@@ -106,7 +110,7 @@ module NetworkX
     # @example
     #   graph.number_of_edges
     def number_of_edges
-      @adj.values.map(&:length).inject(:+)
+      @adj.values.map(&:length).sum
     end
 
     # Returns the size of graph
@@ -116,11 +120,11 @@ module NetworkX
     #
     # @param is_weighted [Bool] if true, method returns sum of weights of all edges
     #                            else returns number of edges
-    def size(is_weighted=false)
+    def size(is_weighted = false)
       if is_weighted
         graph_size = 0
         @adj.each do |_, hash_val|
-          hash_val.each { |_, v| graph_size += v[:weight] if v.key?(:weight) }
+          hash_val.each { |_, v| graph_size += v[:weight] if v.has_key?(:weight) }
         end
         return graph_size
       end
@@ -152,10 +156,10 @@ module NetworkX
     # @example
     #   graph.reverse
     def reverse
-      new_graph = NetworkX::DiGraph.new(@graph)
-      @nodes.each { |u, attrs| new_graph.add_node(u, attrs) }
+      new_graph = NetworkX::DiGraph.new(**@graph)
+      @nodes.each { |u, attrs| new_graph.add_node(u, **attrs) }
       @adj.each do |u, edges|
-        edges.each { |v, attrs| new_graph.add_edge(v, u, attrs) }
+        edges.each { |v, attrs| new_graph.add_edge(v, u, **attrs) }
       end
       new_graph
     end
@@ -165,16 +169,14 @@ module NetworkX
     # @example
     #   graph.to_undirected
     def to_undirected
-      new_graph = NetworkX::Graph.new(@graph)
-      @nodes.each { |u, attrs| new_graph.add_node(u, attrs) }
+      new_graph = NetworkX::Graph.new(**@graph)
+      @nodes.each { |u, attrs| new_graph.add_node(u, **attrs) }
       @adj.each do |u, edges|
-        edges.each { |v, attrs| new_graph.add_edge(u, v, attrs) }
+        edges.each { |v, attrs| new_graph.add_edge(u, v, **attrs) }
       end
       new_graph
     end
 
-    # TODO: Reduce method complexity and method length
-
     # Returns subgraph consisting of given array of nodes
     #
     # @example
@@ -184,23 +186,22 @@ module NetworkX
     def subgraph(nodes)
       case nodes
       when Array, Set
-        sub_graph = NetworkX::DiGraph.new(@graph)
+        sub_graph = NetworkX::DiGraph.new(**@graph)
         nodes.each do |u|
           raise KeyError, "#{u} does not exist in the current graph!" unless node?(u)
-          sub_graph.add_node(u, @nodes[u])
+
+          sub_graph.add_node(u, **@nodes[u])
           @adj[u].each do |v, uv_attrs|
-            sub_graph.add_edge(u, v, uv_attrs) if @adj[u].key?(v) && nodes.include?(v)
+            sub_graph.add_edge(u, v, **uv_attrs) if @adj[u].has_key?(v) && nodes.include?(v)
           end
-          return sub_graph
         end
+        sub_graph
       else
-        raise ArgumentError, 'Expected Argument to be Array or Set of nodes, '\
-                            "received #{nodes.class.name} instead."
+        raise ArgumentError, 'Expected Argument to be Array or Set of nodes, ' \
+                             "received #{nodes.class.name} instead."
       end
     end
 
-    # TODO: Reduce method complexity and method length
-
     # Returns subgraph consisting of given edges
     #
     # @example
@@ -210,19 +211,24 @@ module NetworkX
     def edge_subgraph(edges)
       case edges
       when Array, Set
-        sub_graph = NetworkX::DiGraph.new(@graph)
+        sub_graph = NetworkX::DiGraph.new(**@graph)
         edges.each do |u, v|
-          raise KeyError, "Edge between #{u} and #{v} does not exist in the graph!" unless @nodes.key?(u)\
-                                                                                    && @adj[u].key?(v)
-          sub_graph.add_node(u, @nodes[u])
-          sub_graph.add_node(v, @nodes[v])
-          sub_graph.add_edge(u, v, @adj[u][v])
+          raise KeyError, "Edge between #{u} and #{v} does not exist in the graph!" unless @nodes.has_key?(u) \
+                                                                                    && @adj[u].has_key?(v)
+
+          sub_graph.add_node(u, **@nodes[u])
+          sub_graph.add_node(v, **@nodes[v])
+          sub_graph.add_edge(u, v, **@adj[u][v])
         end
-        return sub_graph
+        sub_graph
       else
-        raise ArgumentError, 'Expected Argument to be Array or Set of edges, '\
-        "received #{edges.class.name} instead."
+        raise ArgumentError, 'Expected Argument to be Array or Set of edges, ' \
+                             "received #{edges.class.name} instead."
       end
     end
+
+    def directed?
+      true
+    end
   end
 end

data/lib/networkx/flow/capacityscaling.rb

@@ -1,5 +1,3 @@
-# TODO: Reduce module length
-
 module NetworkX
   # Returns a label for unique node
   def self.generate_unique_node
@@ -24,8 +22,6 @@ module NetworkX
     false
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Detects the unboundedness in the residual graph
   def self._detect_unboundedness(residual)
     g = NetworkX::DiGraph.new
@@ -42,14 +38,13 @@ module NetworkX
     raise ArgumentError, 'Negative cost cycle of infinite capacity found!' if negative_edge_cycle(g)
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Returns the residual graph of the given graph
   def self._build_residual_network(graph)
-    raise ArgumentError, 'Sum of demands should be 0!' unless\
+    raise ArgumentError, 'Sum of demands should be 0!' unless \
                          graph.nodes.values.map { |attr| attr[:demand] || 0 }.inject(0, :+).zero?
+
     residual = NetworkX::MultiDiGraph.new(inf: 0)
-    residual.add_nodes(graph.nodes.map { |u, attr| [u, excess: (attr[:demand] || 0) * -1, potential: 0] })
+    residual.add_nodes(graph.nodes.map { |u, attr| [u, {excess: (attr[:demand] || 0) * -1, potential: 0}] })
     inf = Float::INFINITY
     edge_list = []
 
@@ -59,20 +54,20 @@ module NetworkX
       graph.adj.each do |u, u_edges|
         u_edges.each do |v, uv_edges|
           uv_edges.each do |k, attrs|
-            edge_list << [u, v, k, e] if u != v && (attrs[:capacity] || inf) > 0
+            edge_list << [u, v, k, e] if u != v && (attrs[:capacity] || inf).positive?
           end
         end
       end
     else
       graph.adj.each do |u, u_edges|
         u_edges.each do |v, attrs|
-          edge_list << [u, v, 0, attrs] if u != v && (attrs[:capacity] || inf) > 0
+          edge_list << [u, v, 0, attrs] if u != v && (attrs[:capacity] || inf).positive?
         end
       end
     end
 
     temp_inf = [residual.nodes.map { |_u, attrs| attrs[:excess].abs }.inject(0, :+), edge_list.map do |_, _, _, e|
-      (e.key?(:capacity) && e[:capacity] != inf ? e[:capacity] : 0)
+      (e.has_key?(:capacity) && e[:capacity] != inf ? e[:capacity] : 0)
     end.inject(0, :+) * 2].max
     inf = temp_inf.zero? ? 1 : temp_inf
 
@@ -87,8 +82,6 @@ module NetworkX
     residual
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Returns the flowdict of the graph
   def self._build_flow_dict(graph, residual)
     flow_dict = {}
@@ -98,22 +91,24 @@ module NetworkX
       graph.nodes.each_key do |u|
         flow_dict[u] = {}
         graph.adj[u].each do |v, uv_edges|
-          flow_dict[u][v] = Hash[uv_edges.map do |k, e|
-            [k, u != v || (e[:capacity] || inf) <= 0 || (e[:weight] || 0) >= 0 ? 0 : e[:capacity]]
-          end]
+          flow_dict[u][v] = uv_edges.transform_values do |e|
+            u != v || (e[:capacity] || inf) <= 0 || (e[:weight] || 0) >= 0 ? 0 : e[:capacity]
+          end
         end
         residual.adj[u].each do |v, uv_edges|
-          flow_dict[u][v].merge!(Hash[uv_edges.map { |_, val| [val[:temp_key][0], val[:flow]] if val[:flow] > 0 }])
+          flow_dict[u][v].merge!(uv_edges.to_h do |_, val|
+                                   [val[:temp_key][0], val[:flow]] if (val[:flow]).positive?
+                                 end)
         end
       end
     else
       graph.nodes.each_key do |u|
-        flow_dict[u] = Hash[graph.adj[u].map do |v, e|
+        flow_dict[u] = graph.adj[u].to_h do |v, e|
           [v, u != v || (e[:capacity] || inf) <= 0 || (e[:weight] || 0) >= 0 ? 0 : e[:capacity]]
-        end]
+        end
         merge_dict = {}
         residual.adj[u].each do |v, uv_edges|
-          uv_edges.each_value { |attrs| merge_dict[v] = attrs[:flow] if attrs[:flow] > 0 }
+          uv_edges.each_value { |attrs| merge_dict[v] = attrs[:flow] if (attrs[:flow]).positive? }
         end
         flow_dict[u].merge!(merge_dict)
       end
@@ -121,15 +116,6 @@ module NetworkX
     flow_dict
   end
 
-  # Counter for the algorithm
-  @itr = 0
-  def self.count
-    @itr += 1
-    @itr
-  end
-
-  # TODO: Reduce method complexity and method length
-
   # Computes max flow using capacity scaling algorithm
   #
   # @param graph [DiGraph, MultiDiGraph] a graph
@@ -148,19 +134,22 @@ module NetworkX
                      end).max
 
     return flow_cost, _build_flow_dict(graph, residual) if wmax == -inf
+
     r_nodes = residual.nodes
     r_adj = residual.adj
 
-    delta = 2 ** Math.log2(wmax).floor
+    delta = 2**Math.log2(wmax).floor
     while delta >= 1
       r_nodes.each do |u, u_attrs|
         p_u = u_attrs[:potential]
         r_adj[u].each do |v, uv_edges|
           uv_edges.each do |_k, e|
             flow = e[:capacity]
-            next unless e[:weight] - p_u + r_nodes[v][:potential] < 0
+            next unless (e[:weight] - p_u + r_nodes[v][:potential]).negative?
+
             flow = e[:capacity] - e[:flow]
             next unless flow >= delta
+
             e[:flow] += flow
             r_adj[v][u].each_key do |val|
               val[:flow] += val[:temp_key][0] == e[:temp_key][0] && val[:temp_key][1] != e[:temp_key][1] ? -flow : 0
@@ -201,24 +190,31 @@ module NetworkX
           end
           p_u = r_nodes[u][:potential]
           r_adj[u].each do |v, uv_edges|
-            next if d.key?(v)
+            next if d.has_key?(v)
+
             wmin = inf
             uv_edges.each_value do |e|
               next unless e[:capacity] - e[:flow] >= delta
+
               w = e[:weight]
               next unless w < wmin
+
               wmin = w
             end
             next if wmin == inf
+
             d_v = d_u + wmin - p_u + r_nodes[v][:potential]
             next unless h_dict[v] > d_v
+
             h << [d_v, count, v]
             h_dict[v] = d_v
             pred[v] = [u, kmin, emin]
           end
         end
 
-        if !t.nil?
+        if t.nil?
+          s_set.delete(s)
+        else
           while u != s
             v = u
             u, k, e = pred[v]
@@ -233,8 +229,6 @@ module NetworkX
           t_set.delete(t) if r_nodes[t][:excess] > -delta
           d_t = d[t]
           d.each { |node, d_u_node| r_nodes[node][:potential] -= (d_u_node - d_t) }
-        else
-          s_set.delete(s)
         end
       end
       delta = (delta / 2).floor

data/lib/networkx/flow/edmondskarp.rb

@@ -1,6 +1,4 @@
 module NetworkX
-  # TODO: Reduce method complexity and method length
-
   # Helper function to augment the flow in a residual graph
   def self.augment(residual, inf, path)
     flow = inf
@@ -11,6 +9,7 @@ module NetworkX
       u = v
     end
     raise ArgumentError, 'Infinite capacity path!' if flow * 2 > inf
+
     u = path_first_elem
     path.each do |v|
       residual.adj[u][v][:flow] += flow
@@ -20,8 +19,6 @@ module NetworkX
     flow
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Helper function for the bidirectional bfs
   def self.bidirectional_bfs(residual, source, target)
     pred, succ = {source => nil}, {target => nil}
@@ -32,29 +29,34 @@ module NetworkX
         q_s.each do |u|
           residual.adj[u].each do |v, uv_attrs|
             next unless !pred.include?(v) && (uv_attrs[:flow] < uv_attrs[:capacity])
+
             pred[v] = u
-            return [v, pred, succ] if succ.key?(v)
+            return [v, pred, succ] if succ.has_key?(v)
+
             q << v
           end
         end
         return [nil, nil, nil] if q.empty?
+
+        q_s = q
       else
         q_t.each do |u|
           residual.pred[u].each do |v, uv_attrs|
-            next unless !succ.key?(v) && uv_attrs[:flow] < uv_attrs[:capacity]
+            next unless !succ.has_key?(v) && uv_attrs[:flow] < uv_attrs[:capacity]
+
             succ[v] = u
-            return [v, pred, succ] if pred.key?(v)
+            return [v, pred, succ] if pred.has_key?(v)
+
             q << v
           end
         end
         return [nil, nil, nil] if q.empty?
+
         q_t = q
       end
     end
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Core helper function for the EdmondsKarp algorithm
   def self.edmondskarp_core(residual, source, target, cutoff)
     inf = residual.graph[:inf]
@@ -62,6 +64,7 @@ module NetworkX
     while flow_val < cutoff
       v, pred, succ = bidirectional_bfs(residual, source, target)
       break if pred.nil?
+
       path = [v]
       u = v
       while u != source
@@ -79,13 +82,12 @@ module NetworkX
     flow_val
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Helper function for the edmondskarp function
   def self.edmondskarp_impl(graph, source, target, residual, cutoff)
-    raise ArgumentError, 'Source not in graph!' unless graph.nodes.key?(source)
-    raise ArgumentError, 'Target not in graph!' unless graph.nodes.key?(target)
+    raise ArgumentError, 'Source not in graph!' unless graph.nodes.has_key?(source)
+    raise ArgumentError, 'Target not in graph!' unless graph.nodes.has_key?(target)
     raise ArgumentError, 'Source and target are same node!' if source == target
+
     res_graph = residual.nil? ? build_residual_network(graph) : residual.clone
     res_graph.adj.each do |u, u_edges|
       u_edges.each do |v, _attrs|
@@ -94,7 +96,7 @@ module NetworkX
       end
     end
     cutoff = Float::INFINITY if cutoff.nil?
-    res_graph.graph[:flow_val] = edmondskarp_core(res_graph, source, target, cutoff)
+    res_graph.graph[:flow_value] = edmondskarp_core(res_graph, source, target, cutoff)
     res_graph
   end
 
@@ -107,7 +109,7 @@ module NetworkX
   # @param cutoff [Numeric] cutoff for the algorithm
   #
   # @return [DiGraph] a residual graph containing the flow values
-  def self.edmondskarp(graph, source, target, residual=nil, cutoff=nil)
+  def self.edmondskarp(graph, source, target, residual = nil, cutoff = nil)
     edmondskarp_impl(graph, source, target, residual, cutoff)
   end
 end