networkx 0.1.1 → 0.2.0

data/lib/networkx/others/generators.rb

@@ -0,0 +1,237 @@
+require_relative '../../networkx'
+
+module NetworkX
+  class Graph
+    # private class method
+    def self.complete_edges(n)
+      n = (0...n) if n.is_a?(Integer)
+
+      edges = []
+      n.each do |i|
+        n.each do |j|
+          edges << [i, j] if i < j
+        end
+      end
+      edges
+    end
+
+    def self.balanced_tree(r, h)
+      edges = []
+      q = [0]
+      i = 0
+      h.times do
+        t = q.dup
+        q.clear
+        t.each do |v|
+          r.times do
+            i += 1
+            edges << [v, i]
+            q << i
+          end
+        end
+      end
+      graph = new(name: "balanced_tree(#{r}, #{h})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.barbell_graph(m1, m2)
+      edges = complete_edges(m1)
+      edges.concat((m1..m2 + m1).map { |k| [k - 1, k] })
+      edges.concat complete_edges(m1 + m2...m1 + m2 + m1)
+
+      graph = new(name: "barbell_graph(#{m1}, #{m2})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.complete_graph(n)
+      n = (0...n) if n.is_a?(Integer)
+
+      edges = []
+      n.each do |i|
+        n.each do |j|
+          edges << [i, j] if i < j
+        end
+      end
+
+      graph = new(name: "complete_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.circular_ladder_graph(n)
+      edges = (0...n - 1).map { |v| [v, v + 1] }
+      edges << [n - 1, 0]
+      edges.concat((n...2 * n - 1).map { |v| [v, v + 1] })
+      edges << [2 * n - 1, n]
+      edges.concat((0...n).map { |v| [v, v + n] })
+
+      graph = new(name: "circular_ladder_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.cycle_graph(n)
+      edges = (0...n - 1).map { |v| [v, v + 1] }
+      edges << [n - 1, 0]
+
+      graph = new(name: "cycle_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.empty_graph(number_of_nodes)
+      empty_graph = new(name: "empty_graph#{number_of_nodes}")
+      empty_graph.add_nodes_from(0...number_of_nodes)
+      empty_graph
+    end
+
+    def self.ladder_graph(n)
+      edges = (0...n - 1).map { |k| [k, k + 1] }
+      edges.concat((n...2 * n - 1).map { |k| [k, k + 1] })
+      edges.concat((0...n).map { |k| [k, k + n] })
+
+      graph = new(name: "ladder_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.lollipop_graph(m, n)
+      edges = complete_edges(m)
+      edges.concat((m - 1...m - 1 + n).map { |v| [v, v + 1] })
+
+      graph = new(name: "lollipop_graph(#{m}, #{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.null_graph
+      new(name: 'null_graph')
+    end
+
+    def self.path_graph(n)
+      edges = (0...n - 1).map { |v| [v, v + 1] }
+
+      graph = new(name: "path_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.star_graph(n)
+      edges = (1..n).map { |i| [0, i] }
+
+      graph = new(name: "star_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.trivial_graph
+      trivial_graph = new(name: 'trivial_grpph')
+      trivial_graph.add_node(0)
+      trivial_graph
+    end
+
+    def self.wheel_graph(n)
+      edges = (1..n - 1).map { |i| [0, i] }
+      edges.concat((1...n - 1).map { |i| [i, i + 1] })
+      edges << [1, n - 1]
+
+      graph = new(name: "wheel_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.bull_graph
+      edges = [[0, 1], [1, 2], [2, 0], [1, 3], [2, 4]]
+      graph = new(name: 'bull_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.cubical_graph
+      graph = circular_ladder_graph(4)
+      graph.graph[:name] = 'cubical_graph'
+      graph
+    end
+
+    def self.diamond_graph
+      edges = [[0, 1], [0, 2], [1, 2], [1, 3], [2, 3]]
+      graph = new(name: 'diamond_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    # 12
+    def self.dodecahedral_graph
+      edges = (0...19).map { |k| [k, k + 1] }
+      edges.concat [[0, 19], [0, 10], [1, 8], [2, 6], [3, 19], [4, 17], [5, 15], [7, 14], [9, 13], [11, 18], [12, 16]]
+      graph = new(name: 'dodecahedral_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.heawood_graph
+      edges = (0...13).map { |k| [k, k + 1] }
+      edges << [13, 0]
+      edges.concat [[0, 5], [1, 10], [2, 7], [3, 12], [4, 9], [6, 11], [8, 13]]
+      graph = new(name: 'heawood_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.house_graph
+      edges = [[0, 1], [0, 2], [1, 3], [2, 3], [2, 4], [3, 4]]
+      graph = new(name: 'house_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.house_x_graph
+      edges = (0...4).map { |k| [k, k + 1] }
+      edges.concat [[0, 2], [0, 3], [1, 3], [2, 4], [3, 4]]
+      graph = new(name: 'house_x_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.moebius_kantor_graph
+      edges = (0...15).map { |k| [k, k + 1] }
+      edges << [15, 0]
+      edges.concat [[0, 5], [1, 12], [2, 7], [4, 9], [3, 14], [6, 11], [8, 13], [10, 15]]
+      graph = new(name: 'moebius_kantor_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    # 8: 6 nodes, 12 edges
+    def self.octahedral_graph
+      edges = []
+      6.times do |i|
+        6.times do |j|
+          edges << [i, j] if i != j && i + j != 5
+        end
+      end
+      graph = new(name: 'octahedral_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.tetrahedral_graph
+      graph = complete_graph(4)
+      graph.graph[:name] = 'tetrahedral_graph'
+      graph
+    end
+
+    # Experimental For debug.
+    #
+    # @return data for https://hello-world-494ec.firebaseapp.com/
+    def put_graph_x2
+      output = <<~"OUTPUT"
+        #{number_of_nodes} #{number_of_edges}
+        #{edges.map { |edge| edge.join(' ') }.join("\n")}
+      OUTPUT
+      puts output
+    end
+  end
+end

data/lib/networkx/others/grid_2d_graph.rb

@@ -0,0 +1,38 @@
+require_relative '../graph'
+
+class Array
+  include Comparable
+end
+
+# Reference: https://networkx.org/documentation/stable/_modules/networkx/generators/lattice.html#grid_2d_graph
+module NetworkX
+  # @param m [Integer] the number of rows
+  # @param n [Integer] the number of columns
+  # @param create_using [Class] graph class. this is optional. default is `NetworkX::Graph`.
+  def self.grid_2d_graph(m, n, periodic: false, create_using: NetworkX::Graph)
+    warn('sorry, periodic is not done yet') if periodic
+
+    m.is_a?(Integer) or raise(ArgumentError, "[NetworkX] argument m: Integer, not #{m.class}")
+    n.is_a?(Integer) or raise(ArgumentError, "[NetworkX] argument n: Integer, not #{n.class}")
+    create_using.is_a?(Class) \
+      or raise(ArgumentError, "[NetworkX] argument create_using: `Graph` class or children, not #{create_using.class}")
+
+    g = create_using.new
+
+    a = []
+    m.times { |i| n.times { |j| a << [i, j] } }
+    g.add_nodes_from(a)
+
+    e1 = []
+    (m - 1).times { |i| n.times { |j| e1 << [[i, j], [i + 1, j]] } }
+    g.add_edges_from(e1)
+
+    e2 = []
+    m.times { |i| (n - 1).times { |j| e2 << [[i, j], [i, j + 1]] } }
+    g.add_edges_from(e2)
+
+    g.add_edges_from(g.edges.map { |i, j| [j, i] }) if g.directed?
+
+    g
+  end
+end

data/lib/networkx/others/info.rb

@@ -0,0 +1,11 @@
+require_relative '../graph'
+
+module NetworkX
+  def self.info(graph)
+    info = ''
+    info << "Type: #{graph.class}\n"
+    info << "Number of nodes: #{graph.number_of_nodes}\n"
+    info << "Number of edges: #{graph.number_of_edges}\n"
+    info
+  end
+end

data/lib/networkx/others/number_connected_components.rb

@@ -0,0 +1,17 @@
+require_relative '../graph'
+require_relative '../auxillary_functions/union_find'
+
+module NetworkX
+  # @param [NetworkX::Graph] graph
+  #
+  # @return [Integer] the number of connected components on graph
+  def self.number_connected_components(graph)
+    uf = NetworkX::UnionFind.new(graph.nodes(data: false))
+    graph.each_edge { |x, y| uf.unite(x, y) }
+    uf.groups.size
+  end
+
+  class << self
+    alias number_of_connected_components number_connected_components
+  end
+end

data/lib/networkx/others/reads.rb

@@ -0,0 +1,52 @@
+require_relative '../../networkx'
+
+module NetworkX
+  class Graph
+    class << self
+      def read_edgelist(path, comment: '#', delimiter: nil)
+        edges = File.readlines(path).filter_map do |line|
+          line.sub!(/#{comment}.+/, '')
+          line.strip.split(delimiter) if line.strip.size > 0
+        end
+
+        edges.each{|edge| edge.map!{|node| NetworkX.to_number_if_possible(node) } }
+
+        graph = new
+        graph.add_edges(edges)
+        graph
+      end
+      alias read_edges read_edgelist
+
+      def read_weighted_edgelist(path, comment: '#', delimiter: nil)
+        edges = File.readlines(path).filter_map do |line|
+          line.sub!(/#{comment}.+/, '')
+          line.strip.split(delimiter) if line.strip.size > 0
+        end
+
+        edges.map! do |x, y, weight|
+          [
+            NetworkX.to_number_if_possible(x),
+            NetworkX.to_number_if_possible(y),
+            {weight: NetworkX.to_number_if_possible(weight)}
+          ]
+        end
+
+        graph = new
+        graph.add_edges(edges)
+        graph
+      end
+      alias read_weighted_edges read_weighted_edgelist
+    end
+  end
+
+  def self.to_number_if_possible(str)
+    case str
+    when /^[+-]?[0-9]+$/
+      str.to_i
+    when /^([+-]?\d*\.\d*)|(\d*[eE][+-]?\d+)$/
+      str.to_f
+    else
+      str
+    end
+  end
+end

data/lib/networkx/shortest_path/astar.rb

@@ -1,6 +1,4 @@
 module NetworkX
-  # TODO: Reduce method complexity and method length
-
   # Returns path using astar algorithm between source and target
   #
   # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
@@ -10,9 +8,11 @@ module NetworkX
   #
   # @return [Array<Object>] an array of nodes forming a path between source
   #                         and target
-  def self.astar_path(graph, source, target, heuristic=nil)
-    warn 'A* is not implemented for MultiGraph and MultiDiGraph'
+  def self.astar_path(graph, source, target, heuristic = nil)
+    warn 'A* is not implemented for MultiGraph and MultiDiGraph' if graph.is_a?(MultiGraph) || graph.is_a?(MultiDiGraph)
+
     raise ArgumentError, 'Either source or target is not in graph' unless graph.node?(source) && graph.node?(target)
+
     count = ->(i) { i + 1 }
     i = -1
     heuristic ||= (->(_u, _v) { 0 })
@@ -33,14 +33,15 @@ module NetworkX
         return path
       end
 
-      next if explored.key?(curnode)
+      next if explored.has_key?(curnode)
 
       explored[curnode] = parent
 
       graph.adj[curnode].each do |u, attrs|
-        next if explored.key?(u)
+        next if explored.has_key?(u)
+
         ncost = dist + (attrs[:weight] || 1)
-        if enqueued.key?(u)
+        if enqueued.has_key?(u)
           qcost, = enqueued[u]
           next if qcost <= ncost
         else
@@ -61,8 +62,9 @@ module NetworkX
   # @param heuristic [] a lambda to compute heuristic b/w two nodes
   #
   # @return [Numeric] the length of the path
-  def self.astar_path_length(graph, source, target, heuristic=nil)
+  def self.astar_path_length(graph, source, target, heuristic = nil)
     raise ArgumentError, 'Either source or target is not in graph' unless graph.node?(source) && graph.node?(target)
+
     path = astar_path(graph, source, target, heuristic)
     path_length = 0
     (1..(path.length - 1)).each { |i| path_length += (graph.adj[path[i - 1]][path[i]][:weight] || 1) }

data/lib/networkx/shortest_path/dense.rb

@@ -1,6 +1,4 @@
 module NetworkX
-  # TODO: Reduce method length and method complexity
-
   # Returns the all pair distance between all the nodes
   #
   # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
@@ -22,7 +20,7 @@ module NetworkX
     as_hash = {}
     (0..(nodelen - 1)).each do |i|
       (0..(nodelen - 1)).each do |j|
-        as_hash[index[i]] = {} unless as_hash.key?(index[i])
+        as_hash[index[i]] = {} unless as_hash.has_key?(index[i])
         as_hash[index[i]][index[j]] = a[i, j]
       end
     end

data/lib/networkx/shortest_path/unweighted.rb

@@ -1,9 +1,7 @@
 module NetworkX
-  # TODO: Reduce method length
-
   # Helper function for single source shortest path length
   def self.help_single_shortest_path_length(adj, firstlevel, cutoff)
-    iterator = Enumerator.new do |e|
+    Enumerator.new do |e|
       seen = {}
       level = 0
       nextlevel = firstlevel
@@ -12,7 +10,8 @@ module NetworkX
         thislevel = nextlevel
         nextlevel = {}
         thislevel.each do |u, _attrs|
-          next if seen.key?(u)
+          next if seen.has_key?(u)
+
           seen[u] = level
           nextlevel.merge!(adj[u])
           e.yield [u, level]
@@ -21,7 +20,6 @@ module NetworkX
       end
       seen.clear
     end
-    iterator
   end
 
   # Computes shortest path values to all nodes from a given node
@@ -31,8 +29,9 @@ module NetworkX
   # @param cutoff [Numeric, nil] cutoff for the shortest path algorithm
   #
   # @return [Array<Object, Numeric>] path lengths for all nodes
-  def self.single_source_shortest_path_length(graph, source, cutoff=nil)
+  def self.single_source_shortest_path_length(graph, source, cutoff = nil)
     raise ArgumentError, 'Source not found in the Graph!' unless graph.node?(source)
+
     cutoff = Float::INFINITY if cutoff.nil?
     nextlevel = {source => 1}
     help_single_shortest_path_length(graph.adj, nextlevel, cutoff).take(graph.nodes.length)
@@ -44,14 +43,12 @@ module NetworkX
   # @param cutoff [Numeric, nil] cutoff for the shortest path algorithm
   #
   # @return [Array<Object, Array<Object, Numeric>>] path lengths for all nodes from all nodes
-  def self.all_pairs_shortest_path_length(graph, cutoff=nil)
+  def self.all_pairs_shortest_path_length(graph, cutoff = nil)
     shortest_paths = []
     graph.nodes.each_key { |n| shortest_paths << [n, single_source_shortest_path_length(graph, n, cutoff)] }
     shortest_paths
   end
 
-  # TODO: Reduce method length
-
   # Helper function for finding single source shortest path
   def self.help_single_shortest_path(adj, firstlevel, paths, cutoff)
     level = 0
@@ -61,7 +58,7 @@ module NetworkX
       nextlevel = {}
       thislevel.each_key do |u|
         adj[u].each_key do |v|
-          unless paths.key?(v)
+          unless paths.has_key?(v)
             paths[v] = paths[u] + [v]
             nextlevel[v] = 1
           end
@@ -79,8 +76,9 @@ module NetworkX
   # @param cutoff [Numeric, nil] cutoff for the shortest path algorithm
   #
   # @return [Array<Object, Array<Object, Array<Object>>>] path lengths for all nodes from all nodes
-  def self.single_source_shortest_path(graph, source, cutoff=nil)
+  def self.single_source_shortest_path(graph, source, cutoff = nil)
     raise ArgumentError, 'Source not found in the Graph!' unless graph.node?(source)
+
     cutoff = Float::INFINITY if cutoff.nil?
     nextlevel = {source => 1}
     paths = {source => [source]}
@@ -93,14 +91,12 @@ module NetworkX
   # @param cutoff [Numeric, nil] cutoff for the shortest path algorithm
   #
   # @return [Array<Object, Hash {Object => Array<Object> }>] paths for all nodes from all nodes
-  def self.all_pairs_shortest_path(graph, cutoff=nil)
+  def self.all_pairs_shortest_path(graph, cutoff = nil)
     shortest_paths = []
     graph.nodes.each_key { |n| shortest_paths << [n, single_source_shortest_path(graph, n, cutoff)] }
     shortest_paths
   end
 
-  # TODO: Reduce method length and method complexity
-
   # Computes shortest paths to all nodes from all nodes
   #
   # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
@@ -111,8 +107,9 @@ module NetworkX
   # @return [Array<Hash{ Object => Array<Object> }, Hash{ Object => Numeric }>,
   #         Hash{ Object => Array<Object> }]
   #         predecessors of a given node and/or seen dict
-  def self.predecessor(graph, source, cutoff=nil, return_seen=false)
+  def self.predecessor(graph, source, cutoff = nil, return_seen = false)
     raise ArgumentError, 'Source not found in the Graph!' unless graph.node?(source)
+
     level = 0
     nextlevel = [source]
     seen = {source => level}
@@ -123,7 +120,7 @@ module NetworkX
       nextlevel = []
       thislevel.each do |u|
         graph.adj[u].each_key do |v|
-          if !seen.key?(v)
+          if !seen.has_key?(v)
             pred[v] = [u]
             seen[v] = level
             nextlevel << v