networkx 0.1.0 → 0.2.0

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

@@ -0,0 +1,73 @@
+module NetworkX
+  # Returns path using astar algorithm between source and target
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] a node to start astar from
+  # @param target [Object] a node to end astar
+  # @param heuristic [] a lambda to compute heuristic b/w two nodes
+  #
+  # @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' 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 })
+    heap = Heap.new { |x, y| x[0] < y[0] || (x[0] == y[0] && x[1] < y[1]) }
+    heap << [0, count.call(i), source, 0, nil]
+    enqueued, explored = {}, {}
+
+    until heap.empty?
+      _, _, curnode, dist, parent = heap.pop
+      if curnode == target
+        path = [curnode]
+        node = parent
+        until node.nil?
+          path << node
+          node = explored[node]
+        end
+        path.reverse
+        return path
+      end
+
+      next if explored.has_key?(curnode)
+
+      explored[curnode] = parent
+
+      graph.adj[curnode].each do |u, attrs|
+        next if explored.has_key?(u)
+
+        ncost = dist + (attrs[:weight] || 1)
+        if enqueued.has_key?(u)
+          qcost, = enqueued[u]
+          next if qcost <= ncost
+        else
+          h = heuristic.call(u, target)
+          enqueued[u] = ncost, h
+          heap << [ncost + h, count.call(i), u, ncost, curnode]
+        end
+      end
+    end
+    raise ArgumentError, 'Target not reachable!'
+  end
+
+  # Returns astar path length b/w source and target
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] a node to start astar from
+  # @param target [Object] a node to end astar
+  # @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)
+    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) }
+    path_length
+  end
+end

data/lib/networkx/shortest_path/dense.rb

@@ -0,0 +1,29 @@
+module NetworkX
+  # Returns the all pair distance between all the nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  #
+  # @return [Hash{ Object => { Object => { Numeric }}}] a hash containing distances
+  #                                                     b/w all pairs of nodes
+  def self.floyd_warshall(graph)
+    a, index = to_matrix(graph, Float::INFINITY, 'min')
+    nodelen = graph.nodes.length
+    (0..(nodelen - 1)).each { |i| a[i, i] = 0 }
+    (0..(nodelen - 1)).each do |k|
+      (0..(nodelen - 1)).each do |i|
+        (0..(nodelen - 1)).each do |j|
+          a[i, j] = [a[i, j], a[i, k] + a[k, j]].min
+        end
+      end
+    end
+
+    as_hash = {}
+    (0..(nodelen - 1)).each do |i|
+      (0..(nodelen - 1)).each do |j|
+        as_hash[index[i]] = {} unless as_hash.has_key?(index[i])
+        as_hash[index[i]][index[j]] = a[i, j]
+      end
+    end
+    as_hash
+  end
+end

data/lib/networkx/shortest_path/unweighted.rb

@@ -0,0 +1,136 @@
+module NetworkX
+  # Helper function for single source shortest path length
+  def self.help_single_shortest_path_length(adj, firstlevel, cutoff)
+    Enumerator.new do |e|
+      seen = {}
+      level = 0
+      nextlevel = firstlevel
+
+      while !nextlevel.empty? && cutoff >= level
+        thislevel = nextlevel
+        nextlevel = {}
+        thislevel.each do |u, _attrs|
+          next if seen.has_key?(u)
+
+          seen[u] = level
+          nextlevel.merge!(adj[u])
+          e.yield [u, level]
+        end
+        level += 1
+      end
+      seen.clear
+    end
+  end
+
+  # Computes shortest path values to all nodes from a given node
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source to compute path length from
+  # @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)
+    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)
+  end
+
+  # Computes shortest path values to all nodes from all nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @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)
+    shortest_paths = []
+    graph.nodes.each_key { |n| shortest_paths << [n, single_source_shortest_path_length(graph, n, cutoff)] }
+    shortest_paths
+  end
+
+  # Helper function for finding single source shortest path
+  def self.help_single_shortest_path(adj, firstlevel, paths, cutoff)
+    level = 0
+    nextlevel = firstlevel
+    while !nextlevel.empty? && cutoff > level
+      thislevel = nextlevel
+      nextlevel = {}
+      thislevel.each_key do |u|
+        adj[u].each_key do |v|
+          unless paths.has_key?(v)
+            paths[v] = paths[u] + [v]
+            nextlevel[v] = 1
+          end
+        end
+      end
+      level += 1
+    end
+    paths
+  end
+
+  # Computes single source shortest path from a node to every other node
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source from which shortest paths are needed
+  # @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)
+    raise ArgumentError, 'Source not found in the Graph!' unless graph.node?(source)
+
+    cutoff = Float::INFINITY if cutoff.nil?
+    nextlevel = {source => 1}
+    paths = {source => [source]}
+    help_single_shortest_path(graph.adj, nextlevel, paths, cutoff)
+  end
+
+  # Computes shortest paths to all nodes from all nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @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)
+    shortest_paths = []
+    graph.nodes.each_key { |n| shortest_paths << [n, single_source_shortest_path(graph, n, cutoff)] }
+    shortest_paths
+  end
+
+  # Computes shortest paths to all nodes from all nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] source for which predecessors are needed
+  # @param cutoff [Numeric, nil] cutoff for finding predecessor
+  # @param return_seen [Boolean] if true, returns seen dict
+  #
+  # @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)
+    raise ArgumentError, 'Source not found in the Graph!' unless graph.node?(source)
+
+    level = 0
+    nextlevel = [source]
+    seen = {source => level}
+    pred = {source => []}
+    until nextlevel.empty?
+      level += 1
+      thislevel = nextlevel
+      nextlevel = []
+      thislevel.each do |u|
+        graph.adj[u].each_key do |v|
+          if !seen.has_key?(v)
+            pred[v] = [u]
+            seen[v] = level
+            nextlevel << v
+          elsif seen[v] == level
+            pred[v] << u
+          end
+        end
+      end
+      break if cutoff.nil? && cutoff <= level
+    end
+    return_seen ? [pred, seen] : pred
+  end
+end