rgl 0.4.0 → 0.5.0

data/lib/rgl/topsort.rb

@@ -1,6 +1,6 @@
 # topsort.rb
 
-require 'rgl/traversal'
+require 'rgl/graph_iterator'
 
 module RGL
 
@@ -11,19 +11,19 @@ module RGL
   # 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.
-
+  # 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)
+    def initialize(g)
       super(g)
       set_to_begin
     end
 
-    def set_to_begin				# :nodoc:
+    def set_to_begin # :nodoc:
       @waiting   = Array.new
       @inDegrees = Hash.new(0)
 
@@ -39,7 +39,7 @@ module RGL
       end
     end
 
-    def basic_forward				# :nodoc:
+    def basic_forward # :nodoc:
       u = @waiting.pop
       graph.each_adjacent(u) do |v|
         @inDegrees[v] -= 1
@@ -48,25 +48,32 @@ module RGL
       u
     end
 
-    def at_beginning?; true;            end	# :nodoc: FIXME
-    def at_end?;       @waiting.empty?; end	# :nodoc:
+    def at_beginning?
+      true
+    end
+
+    # :nodoc: FIXME
+    def at_end?
+      @waiting.empty?
+    end # :nodoc:
 
-  end		# class TopsortIterator
+  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.
 
+    # Returns true if the graph contains no cycles. This is only meaningful
+    # for directed graphs. Returns false for undirected graphs.
+    #
     def acyclic?
       topsort_iterator.length == num_vertices
     end
 
-  end                           # module Graph
-end                             # module RGL
+  end # module Graph
+
+end # module RGL

data/lib/rgl/transitivity.rb

@@ -1,14 +1,14 @@
-require 'enumerator'
-
-require 'rgl/adjacency'
 require 'rgl/base'
+require 'rgl/adjacency'
 require '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
+    # 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.
     #
@@ -16,17 +16,18 @@ module RGL
     # 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?
+            "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
+      # 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
+      # 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.
@@ -52,7 +53,7 @@ module RGL
       # 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
+      # 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
@@ -61,7 +62,7 @@ module RGL
           # 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
+          if scc.size > 1 || has_edge?(v, v)
             scc.each do |w|
               g.add_edge(v, w)
             end
@@ -86,8 +87,8 @@ module RGL
     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;
+    # 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.
     #
@@ -95,17 +96,18 @@ module RGL
     # 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?
+            "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
+      # 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
+      # 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
@@ -114,11 +116,9 @@ module RGL
         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
+          # w is reachable from x. Make sure to completely skip the case where
           # x == w.
-          unless Enumerable::Enumerator.new(cg, :each_adjacent, v).any? do |x|
-            x != w && paths_from[x].include?(w)
-          end then
+          unless cg.to_enum(:each_adjacent, v).any? { |x| x != w && paths_from[x].include?(w) }
             tr_cg.add_edge(v, w)
 
             # For each vertex v, track all nodes reachable from v by adding node
@@ -138,7 +138,7 @@ module RGL
       # 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
+      # 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
@@ -148,7 +148,7 @@ module RGL
         # 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
+        if scc.size > 1 || has_edge?(scc_arr.first, scc_arr.first)
           0.upto(scc_arr.size - 2) do |idx|
             g.add_edge(scc_arr[idx], scc_arr[idx + 1])
           end
@@ -157,12 +157,12 @@ module RGL
 
         # Choose a single edge between the members of two different strongly
         # connected component to add to the graph.
-        edges = Enumerable::Enumerator.new(self, :each_edge)
+        edges = self.to_enum(:each_edge)
         tr_cg.each_adjacent(scc) do |scc2|
           g.add_edge(
-            *edges.find do |v, w|
-              scc.member?(v) && scc2.member?(w)
-            end
+              *edges.find do |v, w|
+                scc.member?(v) && scc2.member?(w)
+              end
           )
         end
 
@@ -175,5 +175,7 @@ module RGL
       # Finally, the transitive reduction...
       g
     end
-  end                           # module Graph
-end                             # module RGL
+
+  end # module Graph
+
+end # module RGL

data/lib/rgl/traversal.rb

@@ -2,7 +2,7 @@
 #
 # 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.
+# 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
@@ -10,153 +10,24 @@
 # in a slightly modified fashion (especially for the RGL::DFSIterator).
 
 require 'rgl/base'
-require 'rubygems' rescue LoadError # If using stream gem
-require 'stream'
+require 'rgl/graph_visitor'
+require 'rgl/graph_iterator'
 
 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,
+  # 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.
+  # (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
@@ -165,96 +36,99 @@ module RGL
     attr_accessor :start_vertex
 
     # Create a new BFSIterator on _graph_, starting at vertex _start_.
-
-    def initialize (graph, start=graph.detect{ |x| true })
+    #
+    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:
+    #
+    def at_beginning? # :nodoc:
       @color_map.size == 1
     end
-        
-    # Returns true if @waiting is empty.
 
+    # 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 
+      @waiting = [@start_vertex] # a queue
+      handle_tree_edge(nil, @start_vertex) # discovers start vertex
     end
 
-    def basic_forward				# :nodoc:
+    def basic_forward # :nodoc:
       u = next_vertex
       handle_examine_vertex(u)
-      graph.each_adjacent(u) { |v|
+
+      graph.each_adjacent(u) do |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
+        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
+        else # (u,v) is a non tree edge
           if color_map[v] == :GRAY
-            handle_back_edge(u, v)		# (u,v) has gray target
+            handle_back_edge(u, v) # (u,v) has gray target
           else
-            handle_forward_edge(u, v)		# (u,v) has black target
+            handle_forward_edge(u, v) # (u,v) has black target
           end
         end
-      }
+      end
+
       color_map[u] = :BLACK
-      handle_finish_vertex(u)                       # finish vertex
+      handle_finish_vertex(u) # finish vertex
       u
     end
 
     protected
 
-    def next_vertex				# :nodoc:
+    def next_vertex # :nodoc:
       # waiting is a queue
       @waiting.shift
     end
-  end		# class BFSIterator
 
+  end # class BFSIterator
 
   module Graph
 
     # Returns a BFSIterator, starting at vertex _v_.
 
-    def bfs_iterator (v = self.detect { |x| true})
+    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
+    # 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)
+    def bfs_search_tree_from(v)
       require 'rgl/adjacency'
       bfs  = bfs_iterator(v)
       tree = DirectedAdjacencyGraph.new
-      bfs.set_tree_edge_event_handler { |from, to|
+
+      bfs.set_tree_edge_event_handler do |from, to|
         tree.add_edge(from, to)
-      }
-      bfs.set_to_end				# does the search
+      end
+
+      bfs.set_to_end # does the search
       tree
     end
 
-  end		# module Graph
+  end # module Graph
 
-
-  # Iterator for a depth first search, starting at a given vertex.  The only
+  # 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
@@ -262,11 +136,10 @@ module RGL
       @waiting.pop
     end
 
-  end		# class DFSIterator
-
+  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
+  # 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.
@@ -275,29 +148,28 @@ module RGL
   # 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
+    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 })
+    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
+    # 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)
+    #
+    def depth_first_search(vis = DFSVisitor.new(self), &b)
       each_vertex do |u|
         unless vis.finished_vertex?(u)
           vis.handle_start_vertex(u)
@@ -306,44 +178,34 @@ module RGL
       end
     end
 
-    # Start a depth first search at vertex _u_.  The block _b_ is called on
+    # 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)
+    #
+    def depth_first_visit(u, vis = DFSVisitor.new(self), &b)
       vis.color_map[u] = :GRAY
       vis.handle_examine_vertex(u)
-      each_adjacent(u) { |v|
+
+      each_adjacent(u) do |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
+
+        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
+        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
+            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 
+            vis.handle_forward_edge(u, v)  # (u,v) is a cross or forward edge
           end
         end
-      }
+      end
+
       vis.color_map[u] = :BLACK
-      vis.handle_finish_vertex(u)           # finish vertex
+      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 Graph
 
-end                             # module RGL
+end # module RGL