laser 0.7.0.pre1

data/lib/laser/third_party/rgl/topsort.rb

@@ -0,0 +1,72 @@
+# topsort.rb
+
+require 'laser/third_party/rgl/traversal'
+
+module RGL
+
+  # Topological Sort Iterator
+  #
+  # The topological sort algorithm creates a linear ordering of the vertices
+  # such that if edge (u,v) appears in the graph, then u comes before v in
+  # the ordering. The graph must be a directed acyclic graph (DAG).
+  #
+  # The iterator can also be applied to undirected graph or to a DG graph
+  # which contains a cycle.  In this case, the Iterator does not reach all
+  # vertices.  The implementation of acyclic? uses this fact.
+
+  class TopsortIterator
+
+    include GraphIterator
+
+    def initialize (g)
+      super(g)
+      set_to_begin
+    end
+
+    def set_to_begin				# :nodoc:
+      @waiting   = Array.new
+      @inDegrees = Hash.new(0)
+
+      graph.each_vertex do |u|
+        @inDegrees[u] = 0 unless @inDegrees.has_key?(u)
+        graph.each_adjacent(u) do |v|
+          @inDegrees[v] += 1
+        end
+      end
+
+      @inDegrees.each_pair do |v, indegree|
+        @waiting.push(v) if indegree.zero?
+      end
+    end
+
+    def basic_forward				# :nodoc:
+      u = @waiting.pop
+      graph.each_adjacent(u) do |v|
+        @inDegrees[v] -= 1
+        @waiting.push(v) if @inDegrees[v].zero?
+      end
+      u
+    end
+
+    def at_beginning?; true;            end	# :nodoc: FIXME
+    def at_end?;       @waiting.empty?; end	# :nodoc:
+
+  end		# class TopsortIterator
+
+  module Graph
+
+    # Returns a TopsortIterator.
+
+    def topsort_iterator
+      TopsortIterator.new(self)
+    end
+        
+    # Returns true if the graph contains no cycles.  This is only meaningful
+    # for directed graphs.  Returns false for undirected graphs.
+
+    def acyclic?
+      topsort_iterator.count == num_vertices
+    end
+
+  end                           # module Graph
+end                             # module RGL

data/lib/laser/third_party/rgl/transitivity.rb

@@ -0,0 +1,180 @@
+require 'enumerator'
+
+require 'laser/third_party/rgl/adjacency'
+require 'laser/third_party/rgl/base'
+require 'laser/third_party/rgl/connected_components'
+require 'laser/third_party/rgl/condensation'
+
+module RGL
+  module Graph
+    # Returns an RGL::DirectedAdjacencyGraph which is the transitive closure of
+    # this graph.  Meaning, for each path u -> ... -> v in this graph, the path
+    # is copied and the edge u -> v is added.  This method supports working with
+    # cyclic graphs by ensuring that edges are created between every pair of
+    # vertices in the cycle, including self-referencing edges.
+    #
+    # This method should run in O(|V||E|) time, where |V| and |E| are the number
+    # of vertices and edges respectively.
+    #
+    # Raises RGL::NotDirectedError if run on an undirected graph.
+    def transitive_closure
+      raise NotDirectedError,
+        "transitive_closure only supported for directed graphs" unless directed?
+
+      # Compute a condensation graph in order to hide cycles.
+      cg = condensation_graph
+
+      # Use a depth first search to calculate the transitive closure over the
+      # condensation graph.  This ensures that as we traverse up the graph we
+      # know the transitive closure of each subgraph rooted at each node
+      # starting at the leaves.  Subsequent root nodes which consume these
+      # subgraphs by way of the nodes' immediate successors can then immediately
+      # add edges to the roots of the subgraphs and to every successor of those
+      # roots.
+      tc_cg = DirectedAdjacencyGraph.new
+      cg.depth_first_search do |v|
+        # For each vertex v, w, and x where the edges v -> w and w -> x exist in
+        # the source graph, add edges v -> w and v -> x to the target graph.
+        cg.each_adjacent(v) do |w|
+          tc_cg.add_edge(v, w)
+          tc_cg.each_adjacent(w) do |x|
+            tc_cg.add_edge(v, x)
+          end
+        end
+        # Ensure that a vertex with no in or out edges is added to the graph.
+        tc_cg.add_vertex(v)
+      end
+
+      # Expand the condensed transitive closure.
+      #
+      # For each trivial strongly connected component in the condensed graph,
+      # add the single node it contains to the new graph and add edges for each
+      # edge the node begins in the original graph.
+      # For each NON-trivial strongly connected component in the condensed
+      # graph, add each node it contains to the new graph and add edges to
+      # every node in the strongly connected component, including self
+      # referential edges.  Then for each edge of the original graph from any
+      # of the contained nodes, add edges from each of the contained nodes to
+      # all the edge targets.
+      g = DirectedAdjacencyGraph.new
+      tc_cg.each_vertex do |scc|
+        scc.each do |v|
+          # Add edges between all members of non-trivial strongly connected
+          # components (size > 1) and ensure that self referential edges are
+          # added when necessary for trivial strongly connected components.
+          if scc.size > 1 || has_edge?(v, v) then
+            scc.each do |w|
+              g.add_edge(v, w)
+            end
+          end
+          # Ensure that a vertex with no in or out edges is added to the graph.
+          g.add_vertex(v)
+        end
+        # Add an edge from every member of a strongly connected component to
+        # every member of each strongly connected component to which the former
+        # points.
+        tc_cg.each_adjacent(scc) do |scc2|
+          scc.each do |v|
+            scc2.each do |w|
+              g.add_edge(v, w)
+            end
+          end
+        end
+      end
+
+      # Finally, the transitive closure...
+      g
+    end
+
+    # Returns an RGL::DirectedAdjacencyGraph which is the transitive reduction
+    # of this graph.  Meaning, that each edge u -> v is omitted if path
+    # u -> ... -> v exists. This method supports working with cyclic graphs;
+    # however, cycles are arbitrarily simplified which may lead to variant,
+    # although equally valid, results on equivalent graphs.
+    #
+    # This method should run in O(|V||E|) time, where |V| and |E| are the number
+    # of vertices and edges respectively.
+    #
+    # Raises RGL::NotDirectedError if run on an undirected graph.
+    def transitive_reduction
+      raise NotDirectedError,
+        "transitive_reduction only supported for directed graphs" unless directed?
+
+      # Compute a condensation graph in order to hide cycles.
+      cg = condensation_graph
+
+      # Use a depth first search to compute the transitive reduction over the
+      # condensed graph.  This is similar to the computation of the transitive
+      # closure over the graph in that for any node of the graph all nodes
+      # reachable from the node are tracked.  Using a depth first search ensures
+      # that all nodes reachable from a target node are known when considering
+      # whether or not to add an edge pointing to that target.
+      tr_cg = DirectedAdjacencyGraph.new
+      paths_from = {}
+      cg.depth_first_search do |v|
+        paths_from[v] = Set.new
+        cg.each_adjacent(v) do |w|
+          # Only add the edge v -> w if there is no other edge v -> x such that
+          # w is reachable from x.  Make sure to completely skip the case where
+          # x == w.
+          unless Enumerator.new(cg, :each_adjacent, v).any? do |x|
+            x != w && paths_from[x].include?(w)
+          end then
+            tr_cg.add_edge(v, w)
+
+            # For each vertex v, track all nodes reachable from v by adding node
+            # w to the list as well as all the nodes readable from w.
+            paths_from[v] << w
+            paths_from[v].merge(paths_from[w])
+          end
+        end
+        # Ensure that a vertex with no in or out edges is added to the graph.
+        tr_cg.add_vertex(v)
+      end
+
+      # Expand the condensed transitive reduction.
+      #
+      # For each trivial strongly connected component in the condensed graph,
+      # add the single node it contains to the new graph and add edges for each
+      # edge the node begins in the original graph.
+      # For each NON-trivial strongly connected component in the condensed
+      # graph, add each node it contains to the new graph and add arbitrary
+      # edges between the nodes to form a simple cycle.  Then for each strongly
+      # connected component adjacent to the current one, find and add the first
+      # edge which exists in the original graph, starts in the first strongly
+      # connected component, and ends in the second strongly connected
+      # component.
+      g = DirectedAdjacencyGraph.new
+      tr_cg.each_vertex do |scc|
+        # Make a cycle of the contents of non-trivial strongly connected
+        # components.
+        scc_arr = scc.to_a
+        if scc.size > 1 || has_edge?(scc_arr.first, scc_arr.first) then
+          0.upto(scc_arr.size - 2) do |idx|
+            g.add_edge(scc_arr[idx], scc_arr[idx + 1])
+          end
+          g.add_edge(scc_arr.last, scc_arr.first)
+        end
+
+        # Choose a single edge between the members of two different strongly
+        # connected component to add to the graph.
+        edges = Enumerator.new(self, :each_edge)
+        tr_cg.each_adjacent(scc) do |scc2|
+          g.add_edge(
+            *edges.find do |v, w|
+              scc.member?(v) && scc2.member?(w)
+            end
+          )
+        end
+
+        # Ensure that a vertex with no in or out edges is added to the graph.
+        scc.each do |v|
+          g.add_vertex(v)
+        end
+      end
+
+      # Finally, the transitive reduction...
+      g
+    end
+  end                           # module Graph
+end                             # module RGL

data/lib/laser/third_party/rgl/traversal.rb

@@ -0,0 +1,348 @@
+# traversal.rb
+#
+# This file defines the basic graph traversal algorithm for DFS and BFS search.
+# They are implemented as an RGL::GraphIterator, which is a Stream of vertices
+# of a given graph.  The streams are not reversable.
+#
+# Beside being an iterator in the sense of the Stream mixin, RGL::BFSIterator
+# and RGL::DFSIterator follow the BGL
+# Visitor[http://www.boost.org/libs/graph/doc/visitor_concepts.html] Concepts
+# in a slightly modified fashion (especially for the RGL::DFSIterator).
+
+require 'laser/third_party/rgl/base'
+require 'stream'
+
+module RGL
+
+  module GraphWrapper                                   # :nodoc:
+
+    attr_accessor :graph
+
+    # Creates a new GraphWrapper on _graph_.
+    def initialize (graph)
+      @graph = graph
+    end
+
+  end                           # module GraphWrapper
+
+  # A GraphIterator is the abstract superclass of all Iterators on graphs.
+  # Each such iterator should implement the protocol defined in module Stream.
+  module GraphIterator
+    include Stream
+    include GraphWrapper
+  end
+
+  # Module GraphVisitor defines the BGL
+  # BFS[http://www.boost.org/libs/graph/doc/BFSVisitor.html] Visitor Concept).
+  #
+  # Visitors provide a mechanism for extending an algorithm (i.e., for
+  # customizing what is done at each step of the algorithm).  They allow users
+  # to insert their own operations at various steps within a graph algorithm.
+  #
+  # Graph algorithms typically have multiple event points where one may want to
+  # insert a call-back.  Therefore, visitors have several methods that
+  # correspond to the various event points.  Each algorithm has a different
+  # set of event points.  The following are common to both DFS and BFS search.
+  #
+  #  * examine_vertex
+  #  * finish_vertex
+  #  * examine_edge
+  #  * tree_edge
+  #  * back_edge
+  #  * forward_edge
+  #
+  # These methods are all called handle_* and can be set to appropriate blocks,
+  # using the methods set_*_event_handler, which are defined for each event
+  # mentioned above. 
+  #
+  # As an alternative, you can also override the handle_* methods in a
+  # subclass, to configure the algorithm (as an example, see TarjanSccVisitor).
+  #
+  # During a graph traversal, vertices are *colored* using the colors :GRAY
+  # (when waiting) and :BLACK when finished.  All other vertices are :WHITE.
+  # The color_map is also maintained in the visitor.
+
+  module GraphVisitor
+
+    include GraphWrapper
+
+    attr_reader :color_map
+
+    # Create a new GraphVisitor on _graph_.
+
+    def initialize (graph)
+      super graph
+      reset
+    end
+
+    # Mark each vertex unvisited (i.e. :WHITE)
+
+    def reset
+      @color_map = Hash.new(:WHITE)
+    end
+
+    # Returns true if vertex _v_ is colored :BLACK (i.e. finished).
+
+    def finished_vertex? (v)
+      @color_map[v] == :BLACK
+    end
+ 
+    # Attach a map to the visitor which records the distance of a visited
+    # vertex to the start vertex.
+    #
+ 	# This is similar to BGLs
+	# distance_recorder[http://www.boost.org/libs/graph/doc/distance_recorder.html].
+    #
+    # After the distance_map is attached, the visitor has a new method
+    # distance_to_root, which answers the distance to the start vertex.
+
+    def attach_distance_map (map = Hash.new(0))
+      @dist_map = map
+
+      class << self
+
+        def handle_tree_edge (u, v)
+          super
+          @dist_map[v] = @dist_map[u] + 1
+        end
+
+        # Answer the distance to the start vertex.
+
+        def distance_to_root (v)
+          @dist_map[v]
+        end
+
+      end	# class
+    end
+
+    # Shall we follow the edge (u,v); i.e. v has color :WHITE
+
+    def follow_edge? (u, v)			# :nodoc:
+      @color_map[v] == :WHITE
+    end
+
+    # == Visitor Event Points
+
+    def self.def_event_handler (m)
+      params = m =~ /edge/ ? "u,v" : "u"
+      self.class_eval %{
+        def handle_#{m} (#{params})
+          @#{m}_event_handler.call(#{params}) if defined? @#{m}_event_handler
+        end
+
+        def set_#{m}_event_handler (&b)
+          @#{m}_event_handler = b
+        end
+      }
+    end
+
+    %w[examine_vertex finish_vertex examine_edge tree_edge back_edge
+       forward_edge].each do |m|
+      def_event_handler(m)
+    end
+
+  end		# module GraphVisitor
+
+  # A BFSIterator can be used to traverse a graph from a given start vertex in
+  # breath first search order.  Since the Iterator also mixins the GraphVisitor,
+  # it provides all event points defined there.
+  #
+  # The vertices which are not yet visited are held in the queue @waiting.
+  # During the traversal, vertices are *colored* using the colors :GRAY
+  # (when waiting) and :BLACK when finished.  All other vertices are :WHITE.
+  #
+  # For more doc see the BGL
+  # BFS[http://www.boost.org/libs/graph/doc/BFSVisitor.html] Visitor Concept .
+  #
+  # See the implementation of bfs_search_tree_from for an example usage.
+
+  class BFSIterator
+
+    include GraphIterator
+    include GraphVisitor
+
+    attr_accessor :start_vertex
+
+    # Create a new BFSIterator on _graph_, starting at vertex _start_.
+
+    def initialize (graph, start=graph.detect{ |x| true })
+      super(graph)
+      @start_vertex = start
+      set_to_begin
+    end
+
+    # Returns true if the @color_map has only one entry (for the start vertex).
+
+    def at_beginning?				# :nodoc:
+      @color_map.size == 1
+    end
+        
+    # Returns true if @waiting is empty.
+
+    def at_end?
+      @waiting.empty?
+    end
+
+    # Reset the iterator to the initial state (i.e. at_beginning? == true).
+
+    def set_to_begin
+      color_map[@start_vertex] = :GRAY
+      @waiting = [@start_vertex]		# a queue
+      handle_tree_edge(nil, @start_vertex)	# discovers start vertex 
+    end
+
+    def basic_forward				# :nodoc:
+      u = next_vertex
+      handle_examine_vertex(u)
+      graph.each_adjacent(u) { |v|
+        handle_examine_edge(u, v)
+        if follow_edge?(u, v)			# (u,v) is a tree edge
+          handle_tree_edge(u, v)		# also discovers v
+          color_map[v] = :GRAY			# color of v was :WHITE
+          @waiting.push(v)
+        else					# (u,v) is a non tree edge
+          if color_map[v] == :GRAY
+            handle_back_edge(u, v)		# (u,v) has gray target
+          else
+            handle_forward_edge(u, v)		# (u,v) has black target
+          end
+        end
+      }
+      color_map[u] = :BLACK
+      handle_finish_vertex(u)                       # finish vertex
+      u
+    end
+
+    protected
+
+    def next_vertex				# :nodoc:
+      # waiting is a queue
+      @waiting.shift
+    end
+  end		# class BFSIterator
+
+
+  module Graph
+
+    # Returns a BFSIterator, starting at vertex _v_.
+
+    def bfs_iterator (v = self.detect { |x| true})
+      BFSIterator.new(self, v)
+    end
+
+    # Returns a DirectedAdjacencyGraph, which represents a BFS search tree
+    # starting at _v_.  This method uses the tree_edge_event of BFSIterator
+    # to record all tree edges of the search tree in the result.
+
+    def bfs_search_tree_from (v)
+      require 'laser/third_party/rgl/adjacency'
+      bfs  = bfs_iterator(v)
+      tree = DirectedAdjacencyGraph.new
+      bfs.set_tree_edge_event_handler { |from, to|
+        tree.add_edge(from, to)
+      }
+      bfs.set_to_end				# does the search
+      tree
+    end
+
+  end		# module Graph
+
+
+  # Iterator for a depth first search, starting at a given vertex.  The only
+  # difference from BFSIterator is that @waiting is a stack, instead of a queue.
+  #
+  # Note that this is different from DFSVisitor, which is used in the recursive
+  # version for depth first search (see depth_first_search).
+
+  class DFSIterator < BFSIterator
+
+    def next_vertex
+      # waiting is a stack
+      @waiting.pop
+    end
+
+  end		# class DFSIterator
+
+
+  # A DFSVisitor is needed by the depth_first_search and depth_first_visit
+  # methods of a graph.  Besides the eventpoint of GraphVisitor, it provides
+  # an additional eventpoint start_vertex, which is called when a
+  # depth_first_search starts a new subtree of the depth first forest that is
+  # defined by the search.
+  #
+  # Note that the discover_vertex event defined in the BGL
+  # DFSVisitor[http://www.boost.org/libs/graph/doc/DFSVisitor.html] is not
+  # this is also defined in the common mixin GraphVisitor of DFSVisitor,
+  # DFSIterator, and BFSIterator.
+
+  class DFSVisitor
+
+    include GraphVisitor
+
+    GraphVisitor.def_event_handler("start_vertex")
+
+  end		# class DFSVisitor
+
+
+  module Graph
+
+    # Returns a DFSIterator staring at vertex _v_.
+
+    def dfs_iterator (v = self.detect { |x| true })
+      DFSIterator.new(self, v)
+    end
+
+    # Do a recursive DFS search on the whole graph.  If a block is passed,
+    # it is called on each _finish_vertex_ event.  See
+    # strongly_connected_components for an example usage.
+
+    def depth_first_search (vis = DFSVisitor.new(self), &b)
+      each_vertex do |u|
+        unless vis.finished_vertex?(u)
+          vis.handle_start_vertex(u)
+          depth_first_visit(u, vis, &b)
+        end
+      end
+    end
+
+    # Start a depth first search at vertex _u_.  The block _b_ is called on
+    # each finish_vertex event.
+
+    def depth_first_visit (u, vis = DFSVisitor.new(self), &b)
+      vis.color_map[u] = :GRAY
+      vis.handle_examine_vertex(u)
+      each_adjacent(u) { |v|
+        vis.handle_examine_edge(u, v)
+        if vis.follow_edge?(u, v)            # (u,v) is a tree edge
+          vis.handle_tree_edge(u, v)         # also discovers v
+          vis.color_map[v] = :GRAY           # color of v was :WHITE
+          depth_first_visit(v, vis, &b)
+        else                                 # (u,v) is a non tree edge
+          if vis.color_map[v] == :GRAY
+            vis.handle_back_edge(u, v)       # (u,v) has gray target
+          else
+            vis.handle_forward_edge(u, v)    # (u,v) is a cross or forward edge 
+          end
+        end
+      }
+      vis.color_map[u] = :BLACK
+      vis.handle_finish_vertex(u)           # finish vertex
+      b.call(u)
+    end
+
+  end		# module Graph
+
+=begin
+  def acyclic?
+    has_cycle = false
+    dfs = DFSIterator.new(self)
+    dfs.set_back_edge_event {has_cycle = true}
+    dfs_each(dfs) do |x|
+      puts x,has_cycle,dfs.inspect
+      return false if has_cycle
+    end
+    true
+  end
+=end
+
+end                             # module RGL