networkx 0.1.1 → 0.3.0

data/lib/networkx/graph.rb

@@ -3,10 +3,9 @@ module NetworkX
   #
   # @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
+    attr_reader :adj, :graph
 
     # Constructor for initializing graph
     #
@@ -17,8 +16,6 @@ module NetworkX
     def initialize(**graph_attrs)
       @nodes = {}
       @adj = {}
-      @graph = {}
-
       @graph = graph_attrs
     end
 
@@ -30,16 +27,16 @@ module NetworkX
     # @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 node1 [Object] the first node of the edge
+    # @param node2 [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)
+    def add_edge(node1, node2, **edge_attrs)
+      add_node(node1)
+      add_node(node2)
 
-      edge_attrs = (@adj[node_1][node_2] || {}).merge(edge_attrs)
-      @adj[node_1][node_2] = edge_attrs
-      @adj[node_2][node_1] = edge_attrs
+      edge_attrs = (@adj[node1][node2] || {}).merge(edge_attrs)
+      @adj[node1][node2] = edge_attrs
+      @adj[node2][node1] = edge_attrs
     end
 
     # Adds multiple edges from an array
@@ -50,13 +47,17 @@ module NetworkX
     def add_edges(edges)
       case edges
       when Array
-        edges.each { |node_1, node_2, **attrs| add_edge(node_1, node_2, attrs) }
+        edges.each { |node1, node2, attrs| add_edge(node1, node2, **(attrs || {})) }
       else
-        raise ArgumentError, 'Expected argument to be an Array of edges, '\
+        raise ArgumentError, 'Expected argument to be an Array of edges, ' \
                              "received #{edges.class.name} instead."
       end
     end
 
+    def add_edges_from(rng)
+      rng.each { |node| add_edge(*node) }
+    end
+
     # Adds a node and its attributes to the graph
     #
     # @example Add a node with attribute 'type'
@@ -65,7 +66,7 @@ module NetworkX
     # @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)
+      if @nodes.has_key?(node)
         @nodes[node].merge!(node_attrs)
       else
         @adj[node] = {}
@@ -82,13 +83,31 @@ module NetworkX
     def add_nodes(nodes)
       case nodes
       when Set, Array
-        nodes.each { |node, **node_attrs| add_node(node, node_attrs) }
+        nodes.each { |node, node_attrs| add_node(node, **(node_attrs || {})) }
+      when Range
+        nodes.each { |node| add_node(node) }
       else
-        raise ArgumentError, 'Expected argument to be an Array or Set of nodes, '\
+        raise ArgumentError, 'Expected argument to be an Array/Set/Range of nodes, ' \
                              "received #{nodes.class.name} instead."
       end
     end
 
+    # [TODO][EXPERIMENTAL]
+    #
+    # @param nodes_for_adding [Array | Range | String] nodes
+    def add_nodes_from(nodes_for_adding)
+      case nodes_for_adding
+      when String
+        nodes_for_adding.each_char { |node| add_node(node) }
+      else
+        nodes_for_adding.each { |node| add_node(node) }
+      end
+    end
+
+    def add_path(paths)
+      paths.each_cons(2){|x, y| add_edge(x, y) }
+    end
+
     # Removes node from the graph
     #
     # @example
@@ -96,7 +115,8 @@ module NetworkX
     #
     # @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)
+      raise KeyError, "Error in deleting node #{node} from Graph." unless @nodes.has_key?(node)
+
       @adj[node].each_key { |k| @adj[k].delete(node) }
       @adj.delete(node)
       @nodes.delete(node)
@@ -113,24 +133,26 @@ module NetworkX
       when Set, Array
         nodes.each { |node| remove_node(node) }
       else
-        raise ArgumentError, 'Expected argument to be an Array or Set of nodes, '\
+        raise ArgumentError, 'Expected argument to be an Array or Set of nodes, ' \
                              "received #{nodes.class.name} instead."
       end
     end
+    alias remove_nodes_from remove_nodes
 
     # 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
+    # @param node1 [Object] the first node of the edge
+    # @param node2 [Object] the second node of the edge
+    def remove_edge(node1, node2)
+      raise KeyError, "#{node1} is not a valid node." unless @nodes.has_key?(node1)
+      raise KeyError, "#{node2} is not a valid node" unless @nodes.has_key?(node2)
+      raise KeyError, 'The given edge is not a valid one.' unless @adj[node1].has_key?(node2)
+
+      @adj[node1].delete(node2)
+      @adj[node2].delete(node1) if node1 != node2
     end
 
     # Removes multiple edges from the graph
@@ -142,23 +164,24 @@ module NetworkX
     def remove_edges(edges)
       case edges
       when Array, Set
-        edges.each { |node_1, node_2| remove_edge(node_1, node_2) }
+        edges.each { |node1, node2| remove_edge(node1, node2) }
       else
-        raise ArgumentError, 'Expected Arguement to be Array or Set of edges, '\
+        raise ArgumentError, 'Expected Arguement to be Array or Set of edges, ' \
                              "received #{edges.class.name} instead."
       end
     end
+    alias remove_edges_from remove_edges
 
     # 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 node1 [Object] the first node of the edge
+    # @param node2 [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)
+    def add_weighted_edge(node1, node2, weight)
+      add_edge(node1, node2, weight: weight)
     end
 
     # Adds multiple weighted edges
@@ -170,12 +193,74 @@ module NetworkX
     # @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.'\
+      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.'\
+      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)
+
+      (edges.transpose << weights).transpose.each do |node1, node2, weight|
+        add_weighted_edge(node1, node2, weight)
+      end
+    end
+
+    # [TODO][EXPERIMENTAL]
+    #
+    # @param edges [[Object, Object, Integer|Float]] the weight of edge
+    # @param weight [Symbol] weight name key. default key is `:weight``
+    def add_weighted_edges_from(edges, weight: :weight)
+      edges.each do |s, t, w|
+        add_edge(s, t, **{weight => w})
+      end
+    end
+
+    # [TODO] Current default of `data` is true.
+    # [Alert] Change the default in the futher. Please specify the `data`.
+    #
+    # @param data [bool] true if you want data of each edge
+    #
+    # @return [Hash | Array] if data is true, it returns hash including data.
+    #                        otherwise, simple nodes array.
+    def nodes(data: true)
+      if data
+        @nodes
+      else
+        @nodes.keys
+      end
+    end
+
+    def each_node(data: false, &block)
+      return enum_for(:each_node, data: data) unless block_given?
+
+      data ? @nodes.each(&block) : @nodes.each_key(&block)
+    end
+
+    # [TODO][EXPERIMENTAL]
+    #
+    # @param data [bool] true if you want data of each edge
+    #
+    # @return [Array[[Object, Object]]] edges array
+    def edges(data: false)
+      each_edge(data: data).to_a
+    end
+
+    # [TODO][EXPERIMENTAL]
+    #
+    # @param data [bool] true if you want data of each edge
+    def each_edge(data: false)
+      return enum_for(:each_edge, data: data) unless block_given?
+
+      h = {}
+      @adj.each do |v, ws|
+        ws.each do |w, info|
+          next if v > w
+
+          h[[v, w, info]] = true
+        end
+      end
+      if data
+        h.each { |(v, w, info), _true| yield(v, w, info) }
+      else
+        h.each { |(v, w, _info), _true| yield(v, w) }
       end
     end
 
@@ -192,23 +277,25 @@ module NetworkX
     # Checks if a node is present in the graph
     #
     # @example
-    #   graph.node?(node_1)
+    #   graph.node?(node1)
     #
     # @param node [Object] the node to be checked
     def node?(node)
-      @nodes.key?(node)
+      @nodes.has_key?(node)
     end
+    alias has_node? node?
 
     # Checks if the the edge consisting of two nodes is present in the graph
     #
     # @example
-    #   graph.edge?(node_1, node_2)
+    #   graph.edge?(node1, node2)
     #
-    # @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)
+    # @param node1 [Object] the first node of the edge to be checked
+    # @param node2 [Object] the second node of the edge to be checked
+    def edge?(node1, node2)
+      node?(node1) && @adj[node1].has_key?(node2)
     end
+    alias has_edge? edge?
 
     # Gets the node data
     #
@@ -218,19 +305,21 @@ module NetworkX
     # @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)
+    #   graph.get_edge_data(node1, node2)
     #
-    # @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]
+    # @param node1 [Object] the first node of the edge
+    # @param node2 [Object] the second node of the edge
+    def get_edge_data(node1, node2)
+      raise KeyError, 'No such edge exists!' unless node?(node1) && node?(node2)
+
+      @adj[node1][node2]
     end
 
     # Retus a hash of neighbours of a node
@@ -241,6 +330,7 @@ module NetworkX
     # @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
 
@@ -257,7 +347,7 @@ module NetworkX
     # @example
     #   graph.number_of_edges
     def number_of_edges
-      @adj.values.map(&:length).inject(:+) / 2
+      @adj.values.map(&:length).sum / 2
     end
 
     # Returns the size of the graph
@@ -267,19 +357,17 @@ module NetworkX
     #
     # @param is_weighted [Bool] if true, method returns sum of weights of all edges
     #                           else returns number of edges
-    def size(is_weighted=false)
+    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) }
+          hash_val.each { |_, v| graph_size += v[:weight] if v.has_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
@@ -289,23 +377,22 @@ module NetworkX
     def subgraph(nodes)
       case nodes
       when Array, Set
-        sub_graph = NetworkX::Graph.new(@graph)
+        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])
+          raise KeyError, "#{u} does not exist in the current graph!" unless @nodes.has_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)
+            sub_graph.add_edge(u, v, **edge_val) if @adj[u].has_key?(v) && nodes.include?(v)
           end
-          return sub_graph
         end
+        sub_graph
       else
-        raise ArgumentError, 'Expected Argument to be Array or Set of nodes, '\
+        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
@@ -315,21 +402,41 @@ module NetworkX
     def edge_subgraph(edges)
       case edges
       when Array, Set
-        sub_graph = NetworkX::Graph.new(@graph)
+        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])
+          raise KeyError, "Edge between #{u} and #{v} does not exist in the graph!" unless @nodes.has_key?(u) \
+                                                                                    && @adj[u].has_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
+        sub_graph
       else
-        raise ArgumentError, 'Expected Argument to be Array or Set of edges, '\
-        "received #{edges.class.name} instead."
+        raise ArgumentError, 'Expected Argument to be Array or Set of edges, ' \
+                             "received #{edges.class.name} instead."
       end
     end
 
+    # [EXPERIMENTAL]
+    def degree(nodes = nil)
+      if nodes.nil?
+        @adj.transform_values(&:size)
+      else
+        res = {}
+        nodes.each { |node| res[node] = @adj[node].size }
+        res
+      end
+    end
+
+    def info
+      info = ''
+      info << "Type: #{self.class}\n"
+      info << "Number of nodes: #{number_of_nodes}\n"
+      info << "Number of edges: #{number_of_edges}\n"
+      info
+    end
+
     def multigraph?
       ['NetworkX::MultiGraph', 'NetworkX::MultiDiGraph'].include?(self.class.name)
     end

data/lib/networkx/link_analysis/hits.rb

@@ -1,6 +1,4 @@
 module NetworkX
-  # TODO: Reduce method length and method complexity
-
   # Computes hits and authority scores for all the graphs
   #
   # @param graph [Graph, DiGraph] a graph
@@ -9,10 +7,11 @@ module NetworkX
   # @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)
+  def self.hits(graph, max_iter = 100, tol = 1e-8, nstart)
     return [{}, {}] if graph.nodes.empty?
+
     h = nstart
-    sum = h.values.inject(:+)
+    sum = h.values.sum
     h.each_key { |k| h[k] /= (sum * 1.0) }
     i = 0
     a = {}
@@ -30,8 +29,9 @@ module NetworkX
       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
+      break if h.keys.map { |k| (h[k] - hlast[k]).abs }.sum < tol
       raise ArgumentError, 'Power Iteration failed to converge!' if i > max_iter
+
       i += 1
     end
     [h, a]
@@ -41,19 +41,19 @@ module NetworkX
   #
   # @param graph [Graph, DiGraph] a graph
   #
-  # @return [NMatrix] authority matrix for the graph
+  # @return [Matrix] authority matrix for the graph
   def self.authority_matrix(graph)
     matrix, = to_matrix(graph, 0)
-    matrix.transpose.dot matrix
+    matrix.transpose * matrix
   end
 
   # Computes hub matrix for the graph
   #
   # @param graph [Graph, DiGraph] a graph
   #
-  # @return [NMatrix] hub matrix for the graph
+  # @return [Matrix] hub matrix for the graph
   def self.hub_matrix(graph)
     matrix, = to_matrix(graph, 0)
-    matrix.dot matrix.transpose
+    matrix * matrix.transpose
   end
 end

data/lib/networkx/link_analysis/pagerank.rb

@@ -1,47 +1,45 @@
 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
+  # @return [Hash of Object => Float] pagerank values of the graph
+  def self.pagerank(graph, alpha: 0.85, personalization: nil, eps: 1e-6, max_iter: 100)
+    n = graph.number_of_nodes
+
+    matrix, index_to_node = NetworkX.to_matrix(graph, 0)
+
+    index_from_node = index_to_node.invert
+
+    probabilities = Array.new(n) do |i|
+      total = matrix.row(i).sum
+      (matrix.row(i) / total.to_f).to_a
     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) }
+
+    curr = personalization
+    unless curr
+      curr = Array.new(n)
+      graph.each_node{|node| curr[index_from_node[node]] = 1.0 / n }
     end
 
-    max_iter.times do |_|
+    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)
+
+      n.times do |i|
+        ip = 0.0
+        n.times do |j|
+          ip += probabilities[j][i] * prev[j]
+        end
+        curr[i] = (alpha * ip) + ((1.0 - alpha) / n * 1.0)
       end
-      err = 0
-      dim.times { |i| err += (prev[i] - curr[i]).abs }
-      return curr if err < eps
+
+      err = (0...n).map{|i| (prev[i] - curr[i]).abs }.sum
+      return (0...n).map{|i| [index_to_node[i], curr[i]] }.sort.to_h if err < eps
     end
-    raise ArgumentError, 'PageRank failed to converge!'
+    warn "pagerank() failed within #{max_iter} iterations. Please inclease max_iter: or loosen eps:"
+    (0...n).map{|i| [index_to_node[i], curr[i]] }.sort.to_h
   end
 end