networkx 0.1.0 → 0.2.0

data/lib/networkx/flow/shortestaugmentingpath.rb

@@ -0,0 +1,154 @@
+module NetworkX
+  # 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.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
+    r_nodes = residual.nodes
+    r_pred = residual.pred
+    r_adj = residual.adj
+
+    r_adj.each_value do |u_edges|
+      u_edges.each_value do |attrs|
+        attrs[:flow] = 0
+      end
+    end
+
+    heights = {target => 0}
+    q = [[target, 0]]
+
+    until q.empty?
+      u, height = q.shift
+      height += 1
+      r_pred[u].each do |v, attrs|
+        if !heights.has_key?(v) && attrs[:flow] < attrs[:capacity]
+          heights[v] = height
+          q << [v, height]
+        end
+      end
+    end
+
+    unless heights.has_key?(source)
+      residual.graph[:flow_value] = 0
+      return residual
+    end
+
+    n = graph.nodes.length
+    m = residual.size / 2
+
+    r_nodes.each do |node, attrs|
+      attrs[:height] = heights.has_key?(node) ? heights[node] : n
+      attrs[:curr_edge] = CurrentEdge.new(r_adj[node])
+    end
+
+    counts = [0] * (2 * n - 1)
+    r_nodes.each_value { |attrs| counts[attrs[:height]] += 1 }
+    inf = graph.graph[:inf]
+
+    cutoff = Float::INFINITY if cutoff.nil?
+    flow_value = 0
+    path = [source]
+    u = source
+    d = two_phase ? n : [m**0.5, 2 * (n**(2./ 3))].min.floor
+    done = r_nodes[source][:height] >= d
+
+    until done
+      height = r_nodes[u][:height]
+      curr_edge = r_nodes[u][:curr_edge]
+
+      loop do
+        v, attr = curr_edge.get
+        if height == r_nodes[v][:height] + 1 && attr[:flow] < attr[:capacity]
+          path << v
+          u = v
+          break
+        end
+        begin
+          curr_edge.move_to_next
+        rescue StopIteration
+          if counts[height].zero?
+            residual.graph[:flow_value] = flow_value
+            return residual
+          end
+          height = relabel(u, n, r_adj, r_nodes)
+          if u == source && height >= d
+            if two_phase
+              done = true
+              break
+            else
+              residual.graph[:flow_value] = flow_value
+              return residual
+            end
+          end
+          counts[height] += 1
+          r_nodes[u][:height] = height
+          unless u == source
+            path.pop
+            u = path[-1]
+            break
+          end
+        end
+      end
+      next unless u == target
+
+      flow_value += augment(path, inf, r_adj)
+      if flow_value >= cutoff
+        residual.graph[:flow_value] = flow_value
+        return residual
+      end
+    end
+    flow_value += edmondskarp_core(residual, source, target, cutoff - flow_value)
+    residual.graph[:flow_value] = flow_value
+    residual
+  end
+
+  # Helper function for augmenting flow
+  def augment(path, inf, r_adj)
+    flow = inf
+    temp_path = path.clone
+    u = temp_path.shift
+    temp_path.each do |v|
+      attr = r_adj[u][v]
+      flow = [flow, attr[:capacity] - attr[:flow]].min
+      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|
+      r_adj[u][v][:flow] += flow
+      r_adj[v][u][:flow] -= flow
+      u = v
+    end
+    flow
+  end
+
+  # Helper function to relable a node to create a permissible edge
+  def self.relabel(node, num, r_adj, r_nodes)
+    height = num - 1
+    r_adj[node].each do |v, attrs|
+      height = [height, r_nodes[v][:height]].min if attrs[:flow] < attrs[:capacity]
+    end
+    height + 1
+  end
+
+  # Computes max flow using shortest augmenting path algorithm
+  #
+  # @param graph [DiGraph] a graph
+  # @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 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)
+
+    shortest_augmenting_path_impl(graph, source, target, residual, two_phase, cutoff)
+  end
+end

data/lib/networkx/flow/utils.rb

@@ -0,0 +1,139 @@
+module NetworkX
+  # Helper class for preflow push algorithm
+  class CurrentEdge
+    attr_reader :curr, :edges
+
+    def initialize(edges)
+      @edges = edges
+      @index = {}
+      @n = edges.length
+      @curr = 0
+      edges.each_with_index { |(key, _value), idx| @index[idx] = key }
+    end
+
+    def get
+      [@index[@curr], @edges[@index[@curr]]]
+    end
+
+    def move_to_next
+      @temp = @curr
+      @curr = (@curr + 1) % @n
+      raise StopIteration if @temp == @n - 1
+    end
+  end
+
+  # Helper class for preflow push algorithm
+  class Level
+    attr_reader :inactive, :active
+
+    def initialize
+      @inactive = Set.new
+      @active = Set.new
+    end
+  end
+
+  # Helper class for preflow push algorithm
+  class GlobalRelabelThreshold
+    def initialize(num1, num2, freq)
+      freq = freq.nil? ? Float::INFINITY : freq
+      @threshold = (num1 + num2) / freq
+      @work = 0
+    end
+
+    def add_work(work)
+      @work += work
+    end
+
+    def reached?
+      @work >= @threshold
+    end
+
+    def clear_work
+      @work = 0
+    end
+  end
+
+  # Builds a residual graph from a constituent graph
+  #
+  # @param graph [DiGraph] a graph
+  #
+  # @return [DiGraph] residual graph
+  def self.build_residual_network(graph)
+    raise NotImplementedError, 'MultiGraph and MultiDiGraph not supported!' if graph.multigraph?
+
+    r_network = NetworkX::DiGraph.new(inf: 0, flow_value: 0)
+    r_network.add_nodes(graph.nodes.keys)
+    inf = Float::INFINITY
+    edge_list = []
+
+    graph.adj.each do |u, u_edges|
+      u_edges.each do |v, uv_attrs|
+        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].has_key?(:capacity) && arr[2][:capacity] != inf ? (result + arr[2][:capacity]) : result
+    end
+    inf = inf_chk.zero? ? 1 : inf_chk
+
+    if graph.directed?
+      edge_list.each do |u, v, attrs|
+        r = [attrs[:capacity] || inf, inf].min
+        if r_network.adj[u][v].nil?
+          r_network.add_edge(u, v, capacity: r)
+          r_network.add_edge(v, u, capacity: 0)
+        else
+          r_network[u][v][:capacity] = r
+        end
+      end
+    else
+      edge_list.each do |u, v, attrs|
+        r = [attrs[:capacity] || inf, inf].min
+        r_network.add_edge(u, v, capacity: r)
+        r_network.add_edge(v, u, capacity: r)
+      end
+    end
+    r_network.graph[:inf] = inf
+    r_network
+  end
+
+  # Detects unboundedness in a graph, raises exception when
+  #   infinite capacity flow is found
+  #
+  # @param r_network [DiGraph] a residual graph
+  # @param source [Object] source node
+  # @param target [Object] target node
+  def self.detect_unboundedness(r_network, source, target)
+    q = [source]
+    seen = Set.new([source])
+    inf = r_network.graph[:inf]
+    until q.empty?
+      u = q.shift
+      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
+    end
+  end
+
+  # Build flow dictionary of a graph from its residual graph
+  #
+  # @param graph [DiGraph] a graph
+  # @param residual [DiGraph] residual graph
+  #
+  # @return [Hash{ Object => Hash{ Object => Numeric }] flowdict containing all
+  #                                                   the flow values in the edges
+  def self.build_flow_dict(graph, residual)
+    flow_dict = {}
+    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]).positive? }
+    end
+    flow_dict
+  end
+end