networkx 0.1.1 → 0.2.0

data/lib/networkx/flow/preflowpush.rb

@@ -1,21 +1,24 @@
-# TODO: Reduce module length
-
 module NetworkX
   # Helper function to return an arbitrary element from an iterable object
   def self.arbitrary_element(iterable)
-    iterable.each { |u| return u }
+    if iterable.is_a?(Hash)
+      iterable.first[0]
+    elsif iterable.respond_to?(:first)
+      iterable.first
+    elsif iterable.respond_to?(:[])
+      iterable[0]
+    end
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Helper function to apply the preflow push algorithm
   def self.preflowpush_impl(graph, source, target, residual, globalrelabel_freq, value_only)
-    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!' if source == target
 
     globalrelabel_freq = 0 if globalrelabel_freq.nil?
-    raise ArgumentError, 'Global Relabel Freq must be nonnegative!' if globalrelabel_freq < 0
+    raise ArgumentError, 'Global Relabel Freq must be nonnegative!' if globalrelabel_freq.negative?
+
     r_network = residual.nil? ? build_residual_network(graph) : residual
     detect_unboundedness(r_network, source, target)
 
@@ -30,7 +33,7 @@ module NetworkX
 
     heights = reverse_bfs(target, residual_pred)
 
-    unless heights.key?(source)
+    unless heights.has_key?(source)
       r_network.graph[:flow_value] = 0
       return r_network
     end
@@ -42,25 +45,25 @@ module NetworkX
     grt = GlobalRelabelThreshold.new(n, r_network.size, globalrelabel_freq)
 
     residual_nodes.each do |u, u_attrs|
-      u_attrs[:height] = heights.key?(u) ? heights[u] : (n + 1)
+      u_attrs[:height] = heights.has_key?(u) ? heights[u] : (n + 1)
       u_attrs[:curr_edge] = CurrentEdge.new(residual_adj[u])
     end
 
     residual_adj[source].each do |u, attr|
       flow = attr[:capacity]
-      push(source, u, flow, residual_nodes, residual_adj) if flow > 0
+      push(source, u, flow, residual_nodes, residual_adj) if flow.positive?
     end
 
-    levels = (0..(2 * n - 1)).map { |_| Level.new }
+    levels = (0..((2 * n) - 1)).map { |_| Level.new }
     residual_nodes.each do |u, attr|
       if u != source && u != target
         level = levels[attr[:height]]
-        residual_nodes[u][:excess] > 0 ? level.active.add(u) : level.inactive.add(u)
+        (residual_nodes[u][:excess]).positive? ? level.active.add(u) : level.inactive.add(u)
       end
     end
 
     height = max_height
-    while height > 0
+    while height.positive?
       loop do
         level = levels[height]
         if level.active.empty?
@@ -116,6 +119,7 @@ module NetworkX
   def self.activate(node, source, target, levels, residual_nodes)
     return if node == source || node == target
     return unless level.inactive.include?(node)
+
     level = levels[residual_nodes[node][:height]]
     level.inactive.delete(node)
     level.active.add(node)
@@ -127,10 +131,8 @@ module NetworkX
     r_adj[u_node].map { |v, attr| attr[:flow] < (attr[:capacity] + 1) ? _nodes[v][:height] : Float::INFINITY }.min
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Helper function for discharging a node
-  def self.discharge(u_node, is_phase_1, residual_nodes, residual_adj, height, levels, grt, source, target)
+  def self.discharge(u_node, is_phase1, residual_nodes, residual_adj, height, levels, grt, source, target)
     height_val = residual_nodes[u_node][:height]
     curr_edge = residual_nodes[u_node][:curr_edge]
     next_height = height_val
@@ -151,7 +153,7 @@ module NetworkX
         curr_edge.move_to_next
       rescue StopIteration
         height_val = relabel(u_node, grt, residual_adj, residual_nodes, source, target, levels)
-        if is_phase_1 && height_val >= n - 1
+        if is_phase1 && height_val >= n - 1
           levels[height].active.add(u_node)
           break
         end
@@ -162,8 +164,6 @@ module NetworkX
     next_height
   end
 
-  # TODO: Reduce method complexity
-
   # Helper function for applying gap heuristic
   def self.gap_heuristic(height, levels, residual_nodes)
     ((height + 1)..(max_height)).each do |idx|
@@ -177,8 +177,6 @@ module NetworkX
     end
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Helper function for global relabel heuristic
   def self.global_relabel(from_sink, source, target, residual_nodes, num, levels, residual_pred)
     src = from_sink ? target : source
@@ -186,7 +184,7 @@ module NetworkX
     heights.delete(target) unless from_sink
     max_height = heights.values.max
     if from_sink
-      residual_nodes.each { |u, attr| heights[u] = num + 1 if !heights.key?(u) && attr[:height] < num }
+      residual_nodes.each { |u, attr| heights[u] = num + 1 if !heights.has_key?(u) && attr[:height] < num }
     else
       heights.each_key { |u| heights[u] += num }
       max_height += num
@@ -195,6 +193,7 @@ module NetworkX
     heights.each do |u, new_height|
       old_height = residual_nodes[u][:height]
       next unless new_height != old_height
+
       if levels[old_height].active.include?(u)
         levels[old_height].active.delete(u)
         levels[new_height].active.add(u)
@@ -208,15 +207,13 @@ module NetworkX
   end
 
   # Helper function for augmenting flow
-  def self.push(node_1, node_2, flow, residual_nodes, residual_adj)
-    residual_adj[node_1][node_2][:flow] += flow
-    residual_adj[node_2][node_1][:flow] -= flow
-    residual_nodes[node_1][:excess] -= flow
-    residual_nodes[node_2][:excess] += flow
+  def self.push(node1, node2, flow, residual_nodes, residual_adj)
+    residual_adj[node1][node2][:flow] += flow
+    residual_adj[node2][node1][:flow] -= flow
+    residual_nodes[node1][:excess] -= flow
+    residual_nodes[node2][:excess] += flow
   end
 
-  # TODO: Reduce method length
-
   # Helper function for reverse bfs
   def self.reverse_bfs(src, residual_pred)
     heights = {src => 0}
@@ -226,7 +223,7 @@ module NetworkX
       u, height = q.shift
       height += 1
       residual_pred[u].each do |v, attr|
-        if !heights.key?(v) && attr[:flow] < attr[:capacity]
+        if !heights.has_key?(v) && attr[:flow] < attr[:capacity]
           heights[v] = height
           q << [v, height]
         end
@@ -246,7 +243,7 @@ module NetworkX
   #                             maximum preflow
   #
   # @return [DiGraph] a residual graph containing the flow values
-  def self.preflowpush(graph, source, target, residual=nil, globalrelabel_freq=1, value_only=false)
+  def self.preflowpush(graph, source, target, residual = nil, globalrelabel_freq = 1, value_only = false)
     preflowpush_impl(graph, source, target, residual, globalrelabel_freq, value_only)
   end
 end

data/lib/networkx/flow/shortestaugmentingpath.rb

@@ -1,12 +1,8 @@
-# TODO: Reduce module length
-
 module NetworkX
-  # TODO: Reduce method complexity and method length
-
   # Helper function for running the shortest augmenting path algorithm
   def self.shortest_augmenting_path_impl(graph, source, target, residual, two_phase, cutoff)
-    raise ArgumentError, 'Source is not in the graph!' unless graph.nodes.key?(source)
-    raise ArgumentError, 'Target is not in the graph!' unless graph.nodes.key?(target)
+    raise ArgumentError, 'Source is not in the graph!' unless graph.nodes.has_key?(source)
+    raise ArgumentError, 'Target is not in the graph!' unless graph.nodes.has_key?(target)
     raise ArgumentError, 'Source and Target are the same!' if source == target
 
     residual = residual.nil? ? build_residual_network(graph) : residual
@@ -27,14 +23,14 @@ module NetworkX
       u, height = q.shift
       height += 1
       r_pred[u].each do |v, attrs|
-        if !heights.key?(v) && attrs[:flow] < attrs[:capacity]
+        if !heights.has_key?(v) && attrs[:flow] < attrs[:capacity]
           heights[v] = height
           q << [v, height]
         end
       end
     end
 
-    unless heights.key?(source)
+    unless heights.has_key?(source)
       residual.graph[:flow_value] = 0
       return residual
     end
@@ -43,12 +39,11 @@ module NetworkX
     m = residual.size / 2
 
     r_nodes.each do |node, attrs|
-      attrs[:height] = heights.key?(node) ? heights[node] : n
+      attrs[:height] = heights.has_key?(node) ? heights[node] : n
       attrs[:curr_edge] = CurrentEdge.new(r_adj[node])
     end
 
-    counts = Array.new(2 * n - 1, 0)
-    counts.fill(0)
+    counts = [0] * (2 * n - 1)
     r_nodes.each_value { |attrs| counts[attrs[:height]] += 1 }
     inf = graph.graph[:inf]
 
@@ -56,7 +51,7 @@ module NetworkX
     flow_value = 0
     path = [source]
     u = source
-    d = two_phase ? n : [m ** 0.5, 2 * n ** (2. / 3)].min.floor
+    d = two_phase ? n : [m**0.5, 2 * (n**(2./ 3))].min.floor
     done = r_nodes[source][:height] >= d
 
     until done
@@ -79,12 +74,12 @@ module NetworkX
           end
           height = relabel(u, n, r_adj, r_nodes)
           if u == source && height >= d
-            if !two_phase
-              residual.graph[:flow_value] = flow_value
-              return residual
-            else
+            if two_phase
               done = true
               break
+            else
+              residual.graph[:flow_value] = flow_value
+              return residual
             end
           end
           counts[height] += 1
@@ -97,6 +92,7 @@ module NetworkX
         end
       end
       next unless u == target
+
       flow_value += augment(path, inf, r_adj)
       if flow_value >= cutoff
         residual.graph[:flow_value] = flow_value
@@ -108,8 +104,6 @@ module NetworkX
     residual
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Helper function for augmenting flow
   def augment(path, inf, r_adj)
     flow = inf
@@ -121,6 +115,7 @@ module NetworkX
       u = v
     end
     raise ArgumentError, 'Infinite capacity path!' if flow * 2 > inf
+
     temp_path = path.clone
     u = temp_path.shift
     temp_path.each do |v|
@@ -146,12 +141,14 @@ module NetworkX
   # @param source [Object] source node
   # @param target [Object] target node
   # @param residual [DiGraph, nil] residual graph
-  # @param value_only [Boolean] if true, compute only the maximum flow value
+  # @param _value_only [Boolean] if true, compute only the maximum flow value
   # @param two_phase [Boolean] if true, two phase variant is used
   # @param cutoff [Numeric] cutoff value for the algorithm
   #
   # @return [DiGraph] a residual graph containing the flow values
-  def self.shortest_augmenting_path(graph, source, target, residual=nil, _value_only=false, two_phase=false, cutoff=nil)
+  def self.shortest_augmenting_path(graph, source, target, residual = nil, \
+                                    _value_only = false, two_phase = false, cutoff = nil)
+
     shortest_augmenting_path_impl(graph, source, target, residual, two_phase, cutoff)
   end
 end

data/lib/networkx/flow/utils.rb

@@ -34,9 +34,9 @@ module NetworkX
 
   # Helper class for preflow push algorithm
   class GlobalRelabelThreshold
-    def initialize(num_1, num_2, freq)
+    def initialize(num1, num2, freq)
       freq = freq.nil? ? Float::INFINITY : freq
-      @threshold = (num_1 + num_2) / freq
+      @threshold = (num1 + num2) / freq
       @work = 0
     end
 
@@ -53,8 +53,6 @@ module NetworkX
     end
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Builds a residual graph from a constituent graph
   #
   # @param graph [DiGraph] a graph
@@ -69,31 +67,13 @@ module NetworkX
     edge_list = []
 
     graph.adj.each do |u, u_edges|
-      require 'spec_helper'
-      RSpec.describe NetworkX::DiGraph do
-        subject { graph }
-
-        let(:graph) { described_class.new }
-
-        before do
-          graph.add_edge(1, 2)
-          graph.add_edge(2, 4)
-        end
-
-        context 'when capacity_scaling is called' do
-          subject { NetworkX.capacity_scaling(graph) }
-
-          it { is_expected.to eq([0, {1=>{2=>0}, 2=>{4=>0}, 4=>{}}]) }
-        end
-      end
-
       u_edges.each do |v, uv_attrs|
-        edge_list << [u, v, uv_attrs] if (uv_attrs[:capacity] || inf) > 0 && u != v
+        edge_list << [u, v, uv_attrs] if (uv_attrs[:capacity] || inf).positive? && u != v
       end
     end
 
     inf_chk = 3 * edge_list.inject(0) do |result, arr|
-      arr[2].key?(:capacity) && arr[2][:capacity] != inf ? (result + arr[2][:capacity]) : result
+      arr[2].has_key?(:capacity) && arr[2][:capacity] != inf ? (result + arr[2][:capacity]) : result
     end
     inf = inf_chk.zero? ? 1 : inf_chk
 
@@ -118,8 +98,6 @@ module NetworkX
     r_network
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Detects unboundedness in a graph, raises exception when
   #   infinite capacity flow is found
   #
@@ -135,6 +113,7 @@ module NetworkX
       r_network.adj[u].each do |v, uv_attrs|
         next unless uv_attrs[:capacity] == inf && !seen.include?(v)
         raise ArgumentError, 'Infinite capacity flow!' if v == target
+
         seen << v
         q << v
       end
@@ -153,7 +132,7 @@ module NetworkX
     graph.edges.each do |u, u_edges|
       flow_dict[u] = {}
       u_edges.each_key { |v| flow_dict[u][v] = 0 }
-      u_edges.each_key { |v| flow_dict[u][v] = residual[u][v][:flow] if residual[u][v][:flow] > 0 }
+      u_edges.each_key { |v| flow_dict[u][v] = residual[u][v][:flow] if (residual[u][v][:flow]).positive? }
     end
     flow_dict
   end