networkx 0.1.0 → 0.1.1

data/lib/networkx/flow/shortestaugmentingpath.rb

@@ -0,0 +1,157 @@
+# 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 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.key?(v) && attrs[:flow] < attrs[:capacity]
+          heights[v] = height
+          q << [v, height]
+        end
+      end
+    end
+
+    unless heights.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.key?(node) ? heights[node] : n
+      attrs[:curr_edge] = CurrentEdge.new(r_adj[node])
+    end
+
+    counts = Array.new(2 * n - 1, 0)
+    counts.fill(0)
+    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
+              residual.graph[:flow_value] = flow_value
+              return residual
+            else
+              done = true
+              break
+            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
+
+  # TODO: Reduce method complexity and method length
+
+  # 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,160 @@
+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(num_1, num_2, freq)
+      freq = freq.nil? ? Float::INFINITY : freq
+      @threshold = (num_1 + num_2) / freq
+      @work = 0
+    end
+
+    def add_work(work)
+      @work += work
+    end
+
+    def reached?
+      @work >= @threshold
+    end
+
+    def clear_work
+      @work = 0
+    end
+  end
+
+  # TODO: Reduce method complexity and method length
+
+  # 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|
+      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
+      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
+    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
+
+  # TODO: Reduce method complexity and method length
+
+  # 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] > 0 }
+    end
+    flow_dict
+  end
+end

data/lib/networkx/graph.rb

@@ -0,0 +1,341 @@
+module NetworkX
+  # Describes the class for making Undirected Graphs
+  #
+  # @attr_reader adj [Hash{ Object => Hash{ Object => Hash{ Object => Object } } }]
+  #                  Stores the edges and their attributes in an adjencency list form
+  # @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 Graph
+    attr_reader :adj, :nodes, :graph
+
+    # Constructor for initializing graph
+    #
+    # @example Initialize a graph with attributes 'type' and 'name'
+    #   graph = NetworkX::Graph.new(name: "Social Network", type: "undirected")
+    #
+    # @param graph_attrs [Hash{ Object => Object }] the graph attributes in a hash format
+    def initialize(**graph_attrs)
+      @nodes = {}
+      @adj = {}
+      @graph = {}
+
+      @graph = graph_attrs
+    end
+
+    # Adds the respective edges
+    #
+    # @example Add an edge with attribute name
+    #   graph.add_edge(node1, node2, name: "Edge1")
+    #
+    # @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 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)
+
+      edge_attrs = (@adj[node_1][node_2] || {}).merge(edge_attrs)
+      @adj[node_1][node_2] = edge_attrs
+      @adj[node_2][node_1] = edge_attrs
+    end
+
+    # Adds multiple edges from an array
+    #
+    # @example Add multiple edges without any attributes
+    #   graph.add_edges([['Nagpur', 'Kgp'], ['Noida', 'Kgp']])
+    # @param edges [Array<Object, Object>]
+    def add_edges(edges)
+      case edges
+      when Array
+        edges.each { |node_1, node_2, **attrs| add_edge(node_1, node_2, attrs) }
+      else
+        raise ArgumentError, 'Expected argument to be an Array of edges, '\
+                             "received #{edges.class.name} instead."
+      end
+    end
+
+    # Adds a node and its attributes to the graph
+    #
+    # @example Add a node with attribute 'type'
+    #   graph.add_node("Noida", type: "city")
+    #
+    # @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)
+      if @nodes.key?(node)
+        @nodes[node].merge!(node_attrs)
+      else
+        @adj[node] = {}
+        @nodes[node] = node_attrs
+      end
+    end
+
+    # Adds multiple nodes to the graph
+    #
+    # @example Adds multiple nodes with attribute 'type'
+    #   graph.add_nodes([["Noida", type: "city"], ["Kgp", type: "town"]])
+    #
+    # @param nodes [Array<Object, Hash{ Object => Object }>] the Array of pair containing nodes and its attributes
+    def add_nodes(nodes)
+      case nodes
+      when Set, Array
+        nodes.each { |node, **node_attrs| add_node(node, node_attrs) }
+      else
+        raise ArgumentError, 'Expected argument to be an Array or Set of nodes, '\
+                             "received #{nodes.class.name} instead."
+      end
+    end
+
+    # Removes node from the graph
+    #
+    # @example
+    #   graph.remove_node("Noida")
+    #
+    # @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)
+      @adj[node].each_key { |k| @adj[k].delete(node) }
+      @adj.delete(node)
+      @nodes.delete(node)
+    end
+
+    # Removes multiple nodes from the graph
+    #
+    # @example
+    #   graph.remove_nodes(["Noida", "Bangalore"])
+    #
+    # @param nodes [Array<Object>] the array of nodes to be removed
+    def remove_nodes(nodes)
+      case nodes
+      when Set, Array
+        nodes.each { |node| remove_node(node) }
+      else
+        raise ArgumentError, 'Expected argument to be an Array or Set of nodes, '\
+                             "received #{nodes.class.name} instead."
+      end
+    end
+
+    # Removes edge from the graph
+    #
+    # @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)
+      @adj[node_1].delete(node_2)
+      @adj[node_2].delete(node_1) if node_1 != node_2
+    end
+
+    # Removes multiple edges from the graph
+    #
+    # @example
+    #   graph.remove_edges([%w[Noida Bangalore], %w[Bangalore Chennai]])
+    #
+    # @param edges [Array<Object>] the array of edges to be removed
+    def remove_edges(edges)
+      case edges
+      when Array, Set
+        edges.each { |node_1, node_2| remove_edge(node_1, node_2) }
+      else
+        raise ArgumentError, 'Expected Arguement to be Array or Set of edges, '\
+                             "received #{edges.class.name} instead."
+      end
+    end
+
+    # Adds weighted edge
+    #
+    # @example
+    #   graph.add_weighted_edge('Noida', 'Bangalore', 1000)
+    #
+    # @param node_1 [Object] the first node of the edge
+    # @param node_2 [Object] the second node of the edge
+    # @param weight [Integer] the weight value
+    def add_weighted_edge(node_1, node_2, weight)
+      add_edge(node_1, node_2, weight: weight)
+    end
+
+    # Adds multiple weighted edges
+    #
+    # @example
+    #   graph.add_weighted_edges([['Noida', 'Bangalore'],
+    #                             ['Noida', 'Nagpur']], [1000, 2000])
+    #
+    # @param edges [Array<Object, Object>] the array of edges
+    # @param weights [Array<Integer>] the array of weights
+    def add_weighted_edges(edges, weights)
+      raise ArgumentError, 'edges and weights array must have equal number of elements.'\
+                           unless edges.size == weights.size
+      raise ArgumentError, 'edges and weight must be given in an Array.'\
+                           unless edges.is_a?(Array) && weights.is_a?(Array)
+      (edges.transpose << weights).transpose.each do |node_1, node_2, weight|
+        add_weighted_edge(node_1, node_2, weight)
+      end
+    end
+
+    # Clears the graph
+    #
+    # @example
+    #   graph.clear
+    def clear
+      @adj.clear
+      @nodes.clear
+      @graph.clear
+    end
+
+    # Checks if a node is present in the graph
+    #
+    # @example
+    #   graph.node?(node_1)
+    #
+    # @param node [Object] the node to be checked
+    def node?(node)
+      @nodes.key?(node)
+    end
+
+    # Checks if the the edge consisting of two nodes is present in the graph
+    #
+    # @example
+    #   graph.edge?(node_1, node_2)
+    #
+    # @param node_1 [Object] the first node of the edge to be checked
+    # @param node_2 [Object] the second node of the edge to be checked
+    def edge?(node_1, node_2)
+      node?(node_1) && @adj[node_1].key?(node_2)
+    end
+
+    # Gets the node data
+    #
+    # @example
+    #   graph.get_node_data(node)
+    #
+    # @param node [Object] the node whose data is to be fetched
+    def get_node_data(node)
+      raise ArgumentError, 'No such node exists!' unless node?(node)
+      @nodes[node]
+    end
+
+    # Gets the edge data
+    #
+    # @example
+    #   graph.get_edge_data(node_1, node_2)
+    #
+    # @param node_1 [Object] the first node of the edge
+    # @param node_2 [Object] the second node of the edge
+    def get_edge_data(node_1, node_2)
+      raise KeyError, 'No such edge exists!' unless node?(node_1) && edge?(node_2)
+      @adj[node_1][node_2]
+    end
+
+    # Retus a hash of neighbours of a node
+    #
+    # @example
+    #   graph.neighbours(node)
+    #
+    # @param node [Object] the node whose neighbours are to be fetched
+    def neighbours(node)
+      raise KeyError, 'No such node exists!' unless node?(node)
+      @adj[node]
+    end
+
+    # Returns number of nodes
+    #
+    # @example
+    #   graph.number_of_nodes
+    def number_of_nodes
+      @nodes.length
+    end
+
+    # Returns number of edges
+    #
+    # @example
+    #   graph.number_of_edges
+    def number_of_edges
+      @adj.values.map(&:length).inject(:+) / 2
+    end
+
+    # Returns the size of the graph
+    #
+    # @example
+    #   graph.size(true)
+    #
+    # @param is_weighted [Bool] if true, method returns sum of weights of all edges
+    #                           else returns number of edges
+    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) }
+        end
+        return graph_size / 2
+      end
+      number_of_edges
+    end
+
+    # TODO: Reduce method length and method complexity
+
+    # Returns subgraph consisting of given array of nodes
+    #
+    # @example
+    #   graph.subgraph(%w[Mumbai Nagpur])
+    #
+    # @param nodes [Array<Object>] the nodes to be included in the subgraph
+    def subgraph(nodes)
+      case nodes
+      when Array, Set
+        sub_graph = NetworkX::Graph.new(@graph)
+        nodes.each do |u, _|
+          raise KeyError, "#{u} does not exist in the current graph!" unless @nodes.key?(u)
+          sub_graph.add_node(u, @nodes[u])
+          @adj[u].each do |v, edge_val|
+            sub_graph.add_edge(u, v, edge_val) if @adj[u].key?(v) && nodes.include?(v)
+          end
+          return sub_graph
+        end
+      else
+        raise ArgumentError, 'Expected Argument to be Array or Set of nodes, '\
+                             "received #{nodes.class.name} instead."
+      end
+    end
+
+    # TODO: Reduce method length and method complexity
+
+    # Returns subgraph conisting of given edges
+    #
+    # @example
+    #   graph.edge_subgraph([%w[Nagpur Wardha], %w[Nagpur Mumbai]])
+    #
+    # @param edges [Array<Object, Object>] the edges to be included in the subraph
+    def edge_subgraph(edges)
+      case edges
+      when Array, Set
+        sub_graph = NetworkX::Graph.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])
+        end
+        return sub_graph
+      else
+        raise ArgumentError, 'Expected Argument to be Array or Set of edges, '\
+        "received #{edges.class.name} instead."
+      end
+    end
+
+    def multigraph?
+      ['NetworkX::MultiGraph', 'NetworkX::MultiDiGraph'].include?(self.class.name)
+    end
+
+    def directed?
+      ['NetworkX::DiGraph', 'NetworkX::MultiDiGraph'].include?(self.class.name)
+    end
+  end
+end