networkx 0.1.0 → 0.1.1

data/lib/networkx/link_analysis/hits.rb

@@ -0,0 +1,59 @@
+module NetworkX
+  # TODO: Reduce method length and method complexity
+
+  # Computes hits and authority scores for all the graphs
+  #
+  # @param graph [Graph, DiGraph] a graph
+  # @param max_iter [Integer] max iterations to run the hits algorithm
+  # @param tol [Numeric] tolerences to cut off the loop
+  # @param nstart [Array<Numeric>] starting hub values for the nodes
+  #
+  # @return [Array<Numeric, Numeric>] hits and authority scores
+  def self.hits(graph, max_iter=100, tol=1e-8, nstart)
+    return [{}, {}] if graph.nodes.empty?
+    h = nstart
+    sum = h.values.inject(:+)
+    h.each_key { |k| h[k] /= (sum * 1.0) }
+    i = 0
+    a = {}
+
+    loop do
+      hlast = Marshal.load(Marshal.dump(h))
+      h, a = {}, {}
+      hlast.each do |k, _v|
+        h[k] = 0
+        a[k] = 0
+      end
+      h.each_key { |k| graph.adj[k].each { |nbr, attrs| a[k] += hlast[nbr] * (attrs[:weight] || 1) } }
+      h.each_key { |k| graph.adj[k].each { |nbr, attrs| h[k] += a[nbr] * (attrs[:weight] || 1) } }
+      smax = h.values.max
+      h.each_key { |k| h[k] /= smax }
+      smax = a.values.max
+      a.each_key { |k| a[k] /= smax }
+      break if h.keys.map { |k| (h[k] - hlast[k]).abs }.inject(:+) < tol
+      raise ArgumentError, 'Power Iteration failed to converge!' if i > max_iter
+      i += 1
+    end
+    [h, a]
+  end
+
+  # Computes authority matrix for the graph
+  #
+  # @param graph [Graph, DiGraph] a graph
+  #
+  # @return [NMatrix] authority matrix for the graph
+  def self.authority_matrix(graph)
+    matrix, = to_matrix(graph, 0)
+    matrix.transpose.dot matrix
+  end
+
+  # Computes hub matrix for the graph
+  #
+  # @param graph [Graph, DiGraph] a graph
+  #
+  # @return [NMatrix] hub matrix for the graph
+  def self.hub_matrix(graph)
+    matrix, = to_matrix(graph, 0)
+    matrix.dot matrix.transpose
+  end
+end

data/lib/networkx/link_analysis/pagerank.rb

@@ -0,0 +1,47 @@
+module NetworkX
+  # TODO: Reduce method length and method complexity
+
+  # Computes pagerank values for the graph
+  #
+  # @param graph [Graph] a graph
+  # @param init [Array<Numeric>] initial pagerank values for the nodes
+  # @param alpha [Numeric] the alpha value to compute the pagerank
+  # @param eps [Numeric] tolerence to check for convergence
+  # @param max_iter [Integer] max iterations for the pagerank algorithm to run
+  #
+  # @return [Array<Numeric>] pagerank values of the graph
+  def self.pagerank(graph, init, alpha=0.85, eps=1e-4, max_iter=100)
+    dim = graph.nodes.length
+    raise ArgumentError, 'Init array needs to have same length as number of graph nodes!'\
+                          unless dim == init.length
+    matrix = []
+    elem_ind = {}
+    p = []
+    curr = init.values
+    init.keys.each_with_index { |n, i| elem_ind[n] = i }
+    graph.adj.each do |_u, u_edges|
+      adj_arr = Array.new(dim, 0)
+      u_edges.each do |v, _|
+        adj_arr[elem_ind[v]] = 1
+      end
+      matrix << adj_arr
+    end
+    (0..(dim - 1)).each do |i|
+      p[i] = []
+      (0..(dim - 1)).each { |j| p[i][j] = matrix[i][j] / (matrix[i].inject(:+) * 1.0) }
+    end
+
+    max_iter.times do |_|
+      prev = curr.clone
+      dim.times do |i|
+        ip = 0
+        dim.times { |j| ip += p.transpose[i][j] * prev[j] }
+        curr[i] = (alpha * ip) + (1 - alpha) / (dim * 1.0)
+      end
+      err = 0
+      dim.times { |i| err += (prev[i] - curr[i]).abs }
+      return curr if err < eps
+    end
+    raise ArgumentError, 'PageRank failed to converge!'
+  end
+end

data/lib/networkx/multidigraph.rb

@@ -0,0 +1,240 @@
+module NetworkX
+  # Describes the class for making MultiDiGraphs
+  #
+  # @attr_reader adj [Hash{ Object => Hash{ Object => Hash{ Integer => Hash{ Object => Object } } } }]
+  #                  Stores the edges and their attributes in an adjencency list form
+  # @attr_reader pred [Hash{ Object => Hash{ Object => Hash{ Integer => Hash{ Object => Object } } } }]
+  #                  Stores the reverse 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 MultiDiGraph < DiGraph
+    # Returns a new key
+    #
+    # @param node_1 [Object] the first node of a given edge
+    # @param node_2 [Object] the second node of a given edge
+    def new_edge_key(node_1, node_2)
+      return 0 if @adj[node_1][node_2].nil?
+      key = @adj[node_1][node_2].length
+      key += 1 while @adj[node_1][node_2].key?(key)
+      key
+    end
+
+    # Adds the respective edge
+    #
+    # @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)
+      key = new_edge_key(node_1, node_2)
+      all_edge_attrs = @adj[node_1][node_2] || {}
+      all_edge_attrs[key] = edge_attrs
+      @adj[node_1][node_2] = all_edge_attrs
+      @pred[node_2][node_1] = all_edge_attrs
+    end
+
+    # TODO: Reduce method complexity
+
+    # 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, key=nil)
+      if key.nil?
+        super(node_1, node_2)
+        return
+      end
+      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)
+      raise KeyError, 'The given edge is not a valid one.' unless @adj[node_1][node_2].key?(key)
+      @adj[node_1][node_2].delete(key)
+      @pred[node_2][node_1].delete(key)
+    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
+    # @param key [Integer] the key of the given edge
+    def edge?(node_1, node_2, key=nil)
+      super(node_1, node_2) if key.nil?
+      node?(node_1) && @adj[node_1].key?(node_2) && @adj[node_1][node_2].key?(key)
+    end
+
+    # Returns the undirected version of the graph
+    #
+    # @example
+    #   graph.to_undirected
+    def to_undirected
+      graph = NetworkX::Graph.new(@graph)
+      @nodes.each { |node, node_attr| graph.add_node(node, node_attr) }
+      @adj.each do |node_1, node_1_edges|
+        node_1_edges.each do |node_2, node_1_node_2|
+          edge_attrs = {}
+          node_1_node_2.each { |_key, attrs| edge_attrs.merge!(attrs) }
+          graph.add_edge(node_1, node_2, edge_attrs)
+        end
+      end
+      graph
+    end
+
+    # Returns the directed version of the graph
+    #
+    # @example
+    #   graph.to_directed
+    def to_directed
+      graph = NetworkX::DiGraph.new(@graph)
+      @nodes.each { |node, node_attr| graph.add_node(node, node_attr) }
+      @adj.each do |node_1, node_1_edges|
+        node_1_edges.each do |node_2, node_1_node_2|
+          edge_attrs = {}
+          node_1_node_2.each { |_key, attrs| edge_attrs.merge!(attrs) }
+          graph.add_edge(node_1, node_2, edge_attrs)
+        end
+      end
+      graph
+    end
+
+    # Returns the multigraph version of the graph
+    #
+    # @example
+    #   graph.to_multigraph
+    def to_multigraph
+      graph = NetworkX::MultiGraph.new(@graph)
+      @nodes.each { |node, node_attr| graph.add_node(node, node_attr) }
+      @adj.each do |node_1, node_1_edges|
+        node_1_edges.each_key do |node_2, node_1_node_2|
+          edge_attrs = {}
+          node_1_node_2.each { |_key, attrs| graph.add_edge(node_1, node_2, attrs) }
+          graph.add_edge(node_1, node_2, edge_attrs)
+        end
+      end
+      graph
+    end
+
+    # Returns the reversed version of the graph
+    #
+    # @example
+    #   graph.reverse
+    def reverse
+      new_graph = NetworkX::MultiDiGraph.new(@graph)
+      @nodes.each { |node, attrs| new_graph.add_node(node, attrs) }
+      @adj.each do |u, u_edges|
+        u_edges.each { |v, uv_attrs| uv_attrs.each { |_k, edge_attrs| new_graph.add_edge(v, u, edge_attrs) } }
+      end
+      new_graph
+    end
+
+    # Returns in-degree of a given node
+    #
+    # @example
+    #   graph.in_degree(node)
+    #
+    # @param node [Object] the node whose in degree is to be calculated
+    def in_degree(node)
+      @pred[node].values.map(:length).inject(:+)
+    end
+
+    # Returns out-degree of a given node
+    #
+    # @example
+    #   graph.out_degree(node)
+    #
+    # @param node [Object] the node whose out degree is to be calculated
+    def out_degree(node)
+      @adj[node].values.map(:length).inject(:+)
+    end
+
+    # Returns number of edges
+    #
+    # @example
+    #   graph.number_of_edges
+    def number_of_edges
+      @adj.values.flat_map(&:values).map(&:length).inject(:+)
+    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| v.each { |_, attrs| graph_size += attrs[:weight] if attrs.key?(:weight) } }
+        end
+        return graph_size
+      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::MultiDiGraph.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|
+            edge_val.each { |_, keyval| sub_graph.add_edge(u, v, keyval) 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::MultiDiGraph.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])
+          @adj[u][v].each { |_, keyval| sub_graph.add_edge(u, v, keyval) }
+        end
+        return sub_graph
+      else
+        raise ArgumentError, 'Expected Argument to be Array or Set of edges, '\
+        "received #{edges.class.name} instead."
+      end
+    end
+  end
+end

data/lib/networkx/multigraph.rb

@@ -0,0 +1,171 @@
+module NetworkX
+  # Describes the class for making MultiGraphs
+  #
+  # @attr_reader adj [Hash{ Object => Hash{ Object => Hash{ Integer => 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 gra
+  class MultiGraph < Graph
+    # Returns a new key
+    #
+    # @param node_1 [Object] the first node of a given edge
+    # @param node_2 [Object] the second node of a given edge
+    def new_edge_key(node_1, node_2)
+      return 0 if @adj[node_1][node_2].nil?
+      key = @adj[node_1][node_2].length
+      key += 1 while @adj[node_1][node_2].key?(key)
+      key
+    end
+
+    # Adds the respective edge
+    #
+    # @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)
+      key = new_edge_key(node_1, node_2)
+      all_edge_attrs = @adj[node_1][node_2] || {}
+      all_edge_attrs[key] = edge_attrs
+      @adj[node_1][node_2] = all_edge_attrs
+      @adj[node_2][node_1] = all_edge_attrs
+    end
+
+    # TODO: Reduce method complexity
+
+    # 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, key=nil)
+      if key.nil?
+        super(node_1, node_2)
+        return
+      end
+      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)
+      raise KeyError, 'The given edge is not a valid one.' unless @adj[node_1][node_2].key?(key)
+      @adj[node_1][node_2].delete(key)
+      @adj[node_2][node_1].delete(key)
+    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| v.each { |_, attrs| graph_size += attrs[:weight] if attrs.key?(:weight) } }
+        end
+        return graph_size / 2
+      end
+      number_of_edges
+    end
+
+    # Returns number of edges
+    #
+    # @example
+    #   graph.number_of_edges
+    def number_of_edges
+      @adj.values.flat_map(&:values).map(&:length).inject(:+) / 2
+    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
+    # @param key [Integer] the key of the given edge
+    def edge?(node_1, node_2, key=nil)
+      super(node_1, node_2) if key.nil?
+      node?(node_1) && @adj[node_1].key?(node_2) && @adj[node_1][node_2].key?(key)
+    end
+
+    # Returns the undirected version of the graph
+    #
+    # @example
+    #   graph.to_undirected
+    def to_undirected
+      graph = NetworkX::Graph.new(@graph)
+      @nodes.each { |node, node_attr| graph.add_node(node, node_attr) }
+      @adj.each do |node_1, node_1_edges|
+        node_1_edges.each do |node_2, node_1_node_2|
+          edge_attrs = {}
+          node_1_node_2.each { |_key, attrs| edge_attrs.merge!(attrs) }
+          graph.add_edge(node_1, node_2, edge_attrs)
+        end
+      end
+      graph
+    end
+
+    # TODO: Reduce method complexity and method length
+
+    # 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::MultiGraph.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|
+            edge_val.each { |_, keyval| sub_graph.add_edge(u, v, keyval) 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 complexity and method length
+
+    # 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::MultiGraph.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])
+          @adj[u][v].each { |_, keyval| sub_graph.add_edge(u, v, keyval) }
+        end
+        return sub_graph
+      else
+        raise ArgumentError, 'Expected Argument to be Array or Set of edges, '\
+        "received #{edges.class.name} instead."
+      end
+    end
+  end
+end