networkx 0.1.0 → 0.1.1

data/lib/networkx/flow/capacityscaling.rb

@@ -0,0 +1,255 @@
+# TODO: Reduce module length
+
+module NetworkX
+  # Returns a label for unique node
+  def self.generate_unique_node
+    SecureRandom.uuid
+  end
+
+  # Finds if there is a negative edge cycle in the graph
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  #
+  # @return [Boolean] whether there exists a negative cycle in graph
+  def self.negative_edge_cycle(graph)
+    newnode = generate_unique_node
+    graph.add_edges(graph.nodes.keys.map { |n| [newnode, n] })
+    begin
+      bellmanford_predecesor_distance(graph, newnode)
+    rescue ArgumentError
+      return true
+    ensure
+      graph.remove_node(newnode)
+    end
+    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
+    g.add_nodes(residual.nodes.keys.zip(residual.nodes.values))
+    inf = residual.graph[:inf]
+
+    residual.nodes.each do |u, _attr|
+      residual.adj[u].each do |v, uv_attrs|
+        w = inf
+        uv_attrs.each { |_key, edge_attrs| w = [w, edge_attrs[:weight]].min if edge_attrs[:capacity] == inf }
+        g.add_edge(u, v, weight: w) unless w == inf
+      end
+    end
+    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\
+                         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] })
+    inf = Float::INFINITY
+    edge_list = []
+
+    # TODO: Selfloop edges check
+
+    if graph.multigraph?
+      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
+          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
+        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)
+    end.inject(0, :+) * 2].max
+    inf = temp_inf.zero? ? 1 : temp_inf
+
+    edge_list.each do |u, v, k, e|
+      r = [e[:capacity] || inf, inf].min
+      w = e[:weight] || 0
+      residual.add_edge(u, v, temp_key: [k, true], capacity: r, weight: w, flow: 0)
+      residual.add_edge(v, u, temp_key: [k, false], capacity: 0, weight: -w, flow: 0)
+    end
+    residual.graph[:inf] = inf
+    _detect_unboundedness(residual)
+    residual
+  end
+
+  # TODO: Reduce method complexity and method length
+
+  # Returns the flowdict of the graph
+  def self._build_flow_dict(graph, residual)
+    flow_dict = {}
+    inf = Float::INFINITY
+
+    if graph.multigraph?
+      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]
+        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 }])
+        end
+      end
+    else
+      graph.nodes.each_key do |u|
+        flow_dict[u] = Hash[graph.adj[u].map do |v, e|
+          [v, u != v || (e[:capacity] || inf) <= 0 || (e[:weight] || 0) >= 0 ? 0 : e[:capacity]]
+        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 }
+        end
+        flow_dict[u].merge!(merge_dict)
+      end
+    end
+    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
+  #
+  # @return [Array<Numeric, Hash{ Object => Hash{ Object => Numeric } }>]
+  #          flow cost and flowdict containing all the flow values in the edges
+  def self.capacity_scaling(graph)
+    residual = _build_residual_network(graph)
+    inf = Float::INFINITY
+    flow_cost = 0
+
+    # TODO: Account cost of self-loof edges
+
+    wmax = ([-inf] + residual.adj.each_with_object([]) do |u, arr|
+                       u[1].each { |_, key_attrs| key_attrs.each { |_, attrs| arr << attrs[:capacity] } }
+                     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
+    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
+            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
+            end
+            r_nodes[u][:excess] -= flow
+            r_nodes[v][:excess] += flow
+          end
+        end
+      end
+
+      s_set = Set.new
+      t_set = Set.new
+
+      residual.nodes.each do |u, _attrs|
+        excess = r_nodes[u][:excess]
+        if excess >= delta
+          s_set.add(u)
+        elsif excess <= -delta
+          t_set.add(u)
+        end
+      end
+
+      while !s_set.empty? && !t_set.empty?
+        s = arbitrary_element
+        t = nil
+        d = {}
+        pred = {s => nil}
+        h = Heap.new { |x, y| x[0] < y[0] || (x[0] == y[0] && x[1] < y[1]) }
+        h_dict = {s => 0}
+        h << [0, count, s]
+        until h.empty?
+          d_u, _, u = h.pop
+          h_dict.delete(u)
+          d[u] = d_u
+          if t_set.include?(u)
+            t = u
+            break
+          end
+          p_u = r_nodes[u][:potential]
+          r_adj[u].each do |v, uv_edges|
+            next if d.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?
+          while u != s
+            v = u
+            u, k, e = pred[v]
+            e[:flow] += delta
+            r_adj[v][u].each_key do |val|
+              val[:flow] += val[:temp_key][0] == k[0] && val[:temp_key][1] != k[1] ? -delta : 0
+            end
+          end
+          r_nodes[s][:excess] -= delta
+          r_nodes[t][:excess] += delta
+          s_set.delete(s) if r_nodes[s][:excess] < delta
+          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
+    end
+
+    r_nodes.each_value { |attrs| raise ArgumentError, 'No flow satisfying all demands!' if attrs[:excess] != 0 }
+
+    residual.nodes.each_key do |node|
+      residual.adj[node].each_value do |uv_edges|
+        uv_edges.each_value do |k_attrs|
+          flow = k_attrs[:flow]
+          flow_cost += (flow * k_attrs[:weight])
+        end
+      end
+    end
+    [flow_cost, _build_flow_dict(graph, residual)]
+  end
+end

data/lib/networkx/flow/edmondskarp.rb

@@ -0,0 +1,113 @@
+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
+    path_first_elem = path.shift
+    u = path_first_elem
+    path.each do |v|
+      flow = [flow, residual.adj[u][v][:capacity] - residual.adj[u][v][:flow]].min
+      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
+      residual.adj[v][u][:flow] -= flow
+      u = v
+    end
+    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}
+    q_s, q_t = [source], [target]
+    loop do
+      q = []
+      if q_s.length <= q_t.length
+        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)
+            q << v
+          end
+        end
+        return [nil, nil, nil] if q.empty?
+      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]
+            succ[v] = u
+            return [v, pred, succ] if pred.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]
+    flow_val = 0
+    while flow_val < cutoff
+      v, pred, succ = bidirectional_bfs(residual, source, target)
+      break if pred.nil?
+      path = [v]
+      u = v
+      while u != source
+        u = pred[u]
+        path << u
+      end
+      path.reverse!
+      u = v
+      while u != target
+        u = succ[u]
+        path << u
+      end
+      flow_val += augment(residual, inf, path)
+    end
+    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 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|
+        res_graph.adj[u][v][:flow] = 0
+        res_graph.pred[v][u][:flow] = 0
+      end
+    end
+    cutoff = Float::INFINITY if cutoff.nil?
+    res_graph.graph[:flow_val] = edmondskarp_core(res_graph, source, target, cutoff)
+    res_graph
+  end
+
+  # Computes max flow using edmonds karp algorithm
+  #
+  # @param graph [Graph, DiGraph] a graph
+  # @param source [Object] source node
+  # @param target [Object] target node
+  # @param residual [DiGraph, nil] residual graph
+  # @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)
+    edmondskarp_impl(graph, source, target, residual, cutoff)
+  end
+end

data/lib/networkx/flow/preflowpush.rb

@@ -0,0 +1,252 @@
+# 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 }
+  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 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
+    r_network = residual.nil? ? build_residual_network(graph) : residual
+    detect_unboundedness(r_network, source, target)
+
+    residual_nodes = r_network.nodes
+    residual_adj = r_network.adj
+    residual_pred = r_network.pred
+
+    residual_nodes.each do |u, u_attrs|
+      u_attrs[:excess] = 0
+      residual_adj[u].each { |_v, attrs| attrs[:flow] = 0 }
+    end
+
+    heights = reverse_bfs(target, residual_pred)
+
+    unless heights.key?(source)
+      r_network.graph[:flow_value] = 0
+      return r_network
+    end
+
+    n = r_network.nodes.length
+    max_height = heights.map { |u, h| u == source ? -1 : h }.max
+    heights[source] = n
+
+    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[: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
+    end
+
+    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)
+      end
+    end
+
+    height = max_height
+    while height > 0
+      loop do
+        level = levels[height]
+        if level.active.empty?
+          height -= 1
+          break
+        end
+        old_height = height
+        old_level = level
+        u = arbitrary_element(level.active)
+        height = discharge(u, true, residual_nodes, residual_adj, height, levels, grt, source, target)
+        if grt.reached?
+          height = global_relabel(true, source, target, residual_nodes, n, levels, residual_pred)
+          max_height = height
+          grt.clear_work
+        elsif old_level.active.empty? && old_level.inactive.empty?
+          gap_heuristic(old_height, levels, residual_nodes)
+          height = old_height - 1
+          max_height = height
+        else
+          max_height = [max_height, height].max
+        end
+      end
+    end
+
+    if value_only
+      r_network.graph[:flow_value] = residual_nodes[target][:excess]
+      return r_network
+    end
+
+    height = global_relabel(false, source, target, residual_nodes, n, levels, residual_pred)
+    grt.clear_work
+
+    while height > n
+      loop do
+        level = levels[height]
+        if level.active.empty?
+          height -= 1
+          break
+        end
+        u = arbitrary_element(level.active)
+        height = discharge(u, false, residual_nodes, residual_adj, height, levels, grt, source, target)
+        if grt.reached?
+          height = global_relabel(false, source, target, residual_nodes, n, levels, residual_pred)
+          grt.clear_work
+        end
+      end
+    end
+    r_network.graph[:flow_value] = residual_nodes[target][:excess]
+    r_network
+  end
+
+  # Helper function to move a node from inactive set to active set
+  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)
+  end
+
+  # Helper function to relable a node to create a permissible edge
+  def self.relabel(u_node, grt, r_adj, _r_nodes, _source, _target, _levels)
+    grt.add_work(r_adj[u_node].length)
+    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)
+    height_val = residual_nodes[u_node][:height]
+    curr_edge = residual_nodes[u_node][:curr_edge]
+    next_height = height_val
+    levels[height_val].active.delete(u_node)
+
+    loop do
+      v, attr = curr_edge.get
+      if height_val == residual_nodes[v][:height] + 1 && attr[:flow] < attr[:capacity]
+        flow = [residual_nodes[u_node][:excess], attr[:capacity] - attr[:flow]].min
+        push(u_node, v, flow, residual_nodes, residual_adj)
+        activate(v, source, target, levels, residual_nodes)
+        if residual_nodes[u_node][:excess].zero?
+          levels[height_val].inactive.add(u_node)
+          break
+        end
+      end
+      begin
+        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
+          levels[height].active.add(u_node)
+          break
+        end
+        next_height = height_val
+      end
+    end
+    residual_nodes[u_node][:height] = height_val
+    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|
+      level = levels[idx]
+      level.active.each { |u| residual_nodes[u][:height] = n + 1 }
+      level.inactive.each { |u| residual_nodes[u][:height] = n + 1 }
+      levels[n + 1].active.merge!(level.active)
+      level.active.clear
+      levels[n + 1].inactive.merge!(level.inactive)
+      level.inactive.clear
+    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
+    heights = reverse_bfs(src, residual_pred)
+    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 }
+    else
+      heights.each_key { |u| heights[u] += num }
+      max_height += num
+    end
+    heights.delete(src)
+    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)
+      else
+        levels[old_height].inactive.delete(u)
+        levels[new_height].inactive.add(u)
+      end
+      residual_nodes[u][:height] = new_height
+    end
+    max_height
+  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
+  end
+
+  # TODO: Reduce method length
+
+  # Helper function for reverse bfs
+  def self.reverse_bfs(src, residual_pred)
+    heights = {src => 0}
+    q = [[src, 0]]
+
+    until q.empty?
+      u, height = q.shift
+      height += 1
+      residual_pred[u].each do |v, attr|
+        if !heights.key?(v) && attr[:flow] < attr[:capacity]
+          heights[v] = height
+          q << [v, height]
+        end
+      end
+    end
+    heights
+  end
+
+  # Computes max flow using preflow push algorithm
+  #
+  # @param graph [DiGraph] a graph
+  # @param source [Object] source node
+  # @param target [Object] target node
+  # @param residual [DiGraph, nil] residual graph
+  # @param globalrelabel_freq [Numeric] global relabel freq
+  # @param value_only [Boolean] if false, compute maximum flow else
+  #                             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)
+    preflowpush_impl(graph, source, target, residual, globalrelabel_freq, value_only)
+  end
+end