rgl 0.2.2 → 0.2.3

data/lib/rgl/connected_components.rb

@@ -1,3 +1,5 @@
+# connected_components.rb
+#
 # This file contains the algorithms for the connected components of an
 # undirected graph (each_connected_component) and strongly connected components
 # for directed graphs (strongly_connected_components).
@@ -5,121 +7,132 @@
 require 'rgl/traversal'
 
 module RGL
+
   module Graph
-	# Compute the connected components of an undirected graph using a DFS-based
-	# approach. A <b>connected component</b> of an undirected graph is a set of
-	# vertices that are all reachable from each other.
-	#
-	# The function is implemented as an iterator which calls the client with an
-	# array of vertices for each component.
-	#
-	# It raises an exception if the graph is directed.
-	def each_connected_component
-	  raise NotUndirectedError, "each_connected_component only works for undirected graphs." if directed?
-	  comp = []
-	  vis = DFSVisitor.new(self)
-	  vis.set_finish_vertex_event_handler {|v| comp << v}
-	  vis.set_start_vertex_event_handler {|v|
-		yield comp unless comp.empty?
-		comp = []
-	  }
-	  depth_first_search(vis) {|v|}
-	  yield comp unless comp.empty?
-	end
-
-	# This GraphVisitor is used by strongly_connected_components to compute the
-	# strongly connected components of a directed graph.
-	#
-	# 
-	class TarjanSccVisitor < DFSVisitor
-	  attr_reader :comp_map
-
-	  # Creates a new TarjanSccVisitor for graph _g_, which should be directed.
-	  def initialize(g)
-		super g
-		@root_map = {}
-		@comp_map = {}
-		@discover_time_map = {}
-		@dfs_time = 0
-		@c_index = 0
-		@stack = []
-	  end
-
-	  def handle_examine_vertex(v)
-		@root_map[v] = v
-		@comp_map[v] = -1
-		@dfs_time += 1
-		@discover_time_map[v] = @dfs_time
-		@stack.push v
-	  end
-
-	  def handle_finish_vertex(v)
-		# Search adjacent vertex w with earliest discover time
-		root_v = @root_map[v]
-		graph.each_adjacent(v) do |w|
-		  if @comp_map[w] == -1
-			root_v = min_discover_time(root_v,@root_map[w])
-		  end
-		end
-		@root_map[v] = root_v
-		if root_v == v			# v is topmost vertex of a SCC
-          begin					# pop off all vertices until v
+
+    # Compute the connected components of an undirected graph, using a
+    # DFS (Depth-first search)-based approach.  A _connected component_ of
+    # an undirected graph is a set of vertices that are all reachable
+    # from each other.
+    #
+    # The function is implemented as an iterator which calls the client
+    # with an array of vertices for each component.
+    #
+    # It raises an exception if the graph is directed.
+
+    def each_connected_component
+      raise NotUndirectedError,
+        "each_connected_component only works " +
+        "for undirected graphs." if directed?
+      comp = []
+      vis  = DFSVisitor.new(self)
+      vis.set_finish_vertex_event_handler { |v| comp << v }
+      vis.set_start_vertex_event_handler { |v|
+        yield comp unless comp.empty?
+        comp = []
+      }
+      depth_first_search(vis) { |v| }
+      yield comp unless comp.empty?
+    end
+
+    # This GraphVisitor is used by strongly_connected_components to compute
+    # the strongly connected components of a directed graph.
+
+    class TarjanSccVisitor < DFSVisitor
+
+      attr_reader :comp_map
+
+      # Creates a new TarjanSccVisitor for graph _g_, which should be directed.
+
+      def initialize (g)
+        super g
+        @root_map           = {}
+        @comp_map           = {}
+        @discover_time_map  = {}
+        @dfs_time           = 0
+        @c_index            = 0
+        @stack              = []
+      end
+
+      def handle_examine_vertex (v)
+        @root_map[v] =  v
+        @comp_map[v] =  -1
+        @dfs_time    += 1
+        @discover_time_map[v] = @dfs_time
+        @stack.push(v)
+      end
+
+      def handle_finish_vertex (v)
+        # Search adjacent vertex w with earliest discover time
+        root_v = @root_map[v]
+        graph.each_adjacent(v) do |w|
+          if @comp_map[w] == -1
+            root_v = min_discover_time(root_v, @root_map[w])
+          end
+        end
+        @root_map[v] = root_v
+        if root_v == v                  # v is topmost vertex of a SCC
+          begin                         # pop off all vertices until v
             w = @stack.pop
             @comp_map[w] = @c_index
           end until w == v
           @c_index += 1
         end
-	  end
-
-	  # Return the number of components found so far.
-	  def num_comp
-		@c_index
-	  end
-
-	  private
-
-	  def min_discover_time(u,v)
-		@discover_time_map[u] < @discover_time_map[v] ? u : v
-	  end
-	end							# TarjanSccVisitor
-
-	# This is Tarjan's algorithm for strongly connected components
-	# from his paper "Depth first search and linear graph algorithms".
-	# It calculates the components in a single application of DFS.
-	# We implement the algorithm with the help of the DFSVisitor
-	# TarjanSccVisitor.
-	#
-	# === Definition
-	# 
-	# A <b>strongly connected component</b> of a directed graph G=(V,E) is a
-	# maximal set of vertices U which is in V such that for every pair of
-	# vertices u and  v in U, we have both a path from u to v and path from v to
-	# u. That is to say that u and v are reachable from each other.
-	# 
-	# @Article{Tarjan:1972:DFS,
-	#   author =       "R. E. Tarjan",
-	#   key =          "Tarjan",
-	#   title =        "Depth First Search and Linear Graph Algorithms",
-	#   journal =      "SIAM Journal on Computing",
-	#   volume =       "1",
-	#   number =       "2",
-	#   pages =        "146--160",
-	#   month =        jun,
-	#   year =         "1972",
-	#   CODEN =        "SMJCAT",
-	#   ISSN =         "0097-5397 (print), 1095-7111 (electronic)",
-	#   bibdate =      "Thu Jan 23 09:56:44 1997",
-	#   bibsource =    "Parallel/Multi.bib, Misc/Reverse.eng.bib",
-	# }
-	# 
-	# The output of the algorithm is recorded in a TarjanSccVisitor _vis_.
-	# vis.comp_map will contain numbers giving the component ID assigned to each 
-	# vertex. The number of components is vis.num_comp.
-	def strongly_connected_components
-	  raise NotDirectedError, "strong_components only works for directed graphs." unless directed?
-	  vis = TarjanSccVisitor.new(self)
-	  depth_first_search(vis) {|v|}
-	  vis
-	end
-  end
-end
+      end
+
+      # Return the number of components found so far.
+
+      def num_comp
+        @c_index
+      end
+
+      private
+
+      def min_discover_time (u, v)
+        @discover_time_map[u] < @discover_time_map[v] ? u : v
+      end
+
+    end		# class TarjanSccVisitor
+
+    # This is Tarjan's algorithm for strongly connected components, from his
+    # paper "Depth first search and linear graph algorithms".  It calculates
+    # the components in a single application of DFS.  We implement the
+    # algorithm with the help of the DFSVisitor TarjanSccVisitor.
+    #
+    # === Definition
+    # 
+    # A _strongly connected component_ of a directed graph G=(V,E) is a
+    # maximal set of vertices U which is in V, such that for every pair of
+    # vertices u and  v in U, we have both a path from u to v and a path
+    # from v to u. That is to say, u and v are reachable from each other.
+    # 
+    # @Article{Tarjan:1972:DFS,
+    #   author =       "R. E. Tarjan",
+    #   key =          "Tarjan",
+    #   title =        "Depth First Search and Linear Graph Algorithms",
+    #   journal =      "SIAM Journal on Computing",
+    #   volume =       "1",
+    #   number =       "2",
+    #   pages =        "146--160",
+    #   month =        jun,
+    #   year =         "1972",
+    #   CODEN =        "SMJCAT",
+    #   ISSN =         "0097-5397 (print), 1095-7111 (electronic)",
+    #   bibdate =      "Thu Jan 23 09:56:44 1997",
+    #   bibsource =    "Parallel/Multi.bib, Misc/Reverse.eng.bib",
+    # }
+    # 
+    # The output of the algorithm is recorded in a TarjanSccVisitor _vis_.
+    # vis.comp_map will contain numbers giving the component ID assigned to
+    # each vertex. The number of components is vis.num_comp.
+
+    def strongly_connected_components
+      raise NotDirectedError,
+        "strong_components only works for directed graphs." unless directed?
+      vis = TarjanSccVisitor.new(self)
+      depth_first_search(vis) { |v| }
+      vis
+    end
+
+  end                           # module Graph
+end                             # module RGL

data/lib/rgl/dot.rb

@@ -1,54 +1,61 @@
+# dot.rb
 # 
-# $Id: dot.rb,v 1.4 2002/11/13 21:53:27 monora Exp $
+# $Id: dot.rb,v 1.5 2005/02/04 22:41:46 monora Exp $
 # 
-# Minimal Dot support based on Dave Thomas dot module (included in
-# rdoc). rdot.rb is a modified version which also contains support for
-# undirected graphs.
+# Minimal Dot support, based on Dave Thomas's dot module (included in rdoc).
+# rdot.rb is a modified version which also contains support for undirected
+# graphs.
 
 require 'rgl/rdot'
 
 module RGL
+
   module Graph
-	# Return a DOT::DOTDigraph for directed graphs or a DOT::DOTSubgraph for an
-	# undirected Graph. _params_ can contain any graph property specified in
-	# rdot.rb.
-	def to_dot_graph( params = {} )
-	  params['name'] ||= self.class.name.gsub(/:/,'_')
-	  fontsize = params['fontsize'] ? params['fontsize'] : '8'
-	  graph = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
-	  edge_class = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
-	  each_vertex do |v|
-		name = v.to_s
-		graph << DOT::DOTNode.new('name' => '"' + name + '"',
-								  'fontsize' => fontsize,
-								  'label' => name)
-	  end
-	  each_edge do |u,v|
-		graph << edge_class.new('from' => '"'+ u.to_s + '"',
-								'to' => '"'+ v.to_s + '"',
-								'fontsize' => fontsize)
-	  end
-	  graph
-	end
-
-	# Output the DOT-graph to stream _s_.
-	def print_dotted_on (params = {}, s=$stdout)
-	  s << to_dot_graph(params).to_s << "\n"
-	end
-
-	# Call +dotty+ for the graph which is written to the file 'graph.dot' in the
-	# current directory.
-	def dotty( params = {} )
-	  dotfile = "graph.dot"
-	  File.open(dotfile, "w") {|f|
-		print_dotted_on(params, f)
-	  }
-	  system("dotty", dotfile)
-	end
-
-	# Use +do+ to create a graphical representation of the graph. Returns the
-	# filename of the graphics file.
-	def write_to_graphic_file(fmt='png', dotfile="graph")
+
+  # Return a DOT::DOTDigraph for directed graphs or a DOT::DOTSubgraph for an
+  # undirected Graph.  _params_ can contain any graph property specified in
+  # rdot.rb.
+
+  def to_dot_graph (params = {})
+    params['name'] ||= self.class.name.gsub(/:/,'_')
+    fontsize   = params['fontsize'] ? params['fontsize'] : '8'
+    graph      = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
+    edge_class = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
+    each_vertex do |v|
+      name = v.to_s
+      graph << DOT::DOTNode.new('name'     => '"' + name + '"',
+                                'fontsize' => fontsize,
+                                'label'    => name)
+    end
+    each_edge do |u,v|
+      graph << edge_class.new('from'     => '"'+ u.to_s + '"',
+                              'to'       => '"'+ v.to_s + '"',
+                              'fontsize' => fontsize)
+      end
+      graph
+    end
+
+    # Output the DOT-graph to stream _s_.
+
+    def print_dotted_on (params = {}, s = $stdout)
+      s << to_dot_graph(params).to_s << "\n"
+    end
+
+    # Call +dotty+ for the graph which is written to the file 'graph.dot'
+    # in the # current directory.
+
+    def dotty (params = {})
+      dotfile = "graph.dot"
+      File.open(dotfile, "w") {|f|
+        print_dotted_on(params, f)
+      }
+      system("dotty", dotfile)
+    end
+
+    # Use +do+ to create a graphical representation of the graph.  Returns the
+    # filename of the graphics file.
+
+    def write_to_graphic_file (fmt='png', dotfile="graph")
       src = dotfile + ".dot"
       dot = dotfile + "." + fmt
       
@@ -59,5 +66,6 @@ module RGL
       system( "dot -T#{fmt} #{src} -o #{dot}" )
       dot
     end
-  end
-end
+
+  end                           # module Graph
+end                             # module RGL

data/lib/rgl/graphxml.rb

@@ -1,9 +1,12 @@
+# graphxml.rb
+#
 # This file contains minimal support for creating RGL graphs from the GraphML
-# format (see http://www.graphdrawing.org/graphml). The main purpose is to
+# format (see http://www.graphdrawing.org/graphml).  The main purpose is to
 # have a rich set of example graphs to have some more tests.
 #
-# See the examples directory which contains a subdirectory _north_ with the
-# Graph catalog GraphViz (see http://www.research.att.com/sw/tools/graphviz/refs.html).
+# See the examples directory, which contains a subdirectory _north_ with the
+# Graph catalog GraphViz (see
+# http://www.research.att.com/sw/tools/graphviz/refs.html).
 #
 # We use REXML::StreamListener from the REXML library
 # (http://www.germane-software.com/software/rexml) to parse the grapml files.
@@ -13,40 +16,48 @@ require 'rexml/document'
 require 'rexml/streamlistener'
 
 module RGL
-  # Module GraphXML adds to each class including module MutableGraph a class
+
+  # Module GraphXML adds to each class, including module MutableGraph, a class
   # method from_graphxml.
   #
-  # Attention: Because append_features is used to provide the
-  # functionality GraphXML must be loaded before the concrete class
-  # implementing including MutableGraph is loaded.
+  # Attention: Because append_features is used to provide the functionality,
+  # GraphXML must be loaded before the concrete class including MutableGraph
+  # is loaded.
+
   module GraphXML
-	class MutableGraphParser
-	  include REXML::StreamListener
-	  attr_reader :graph
-	  def initialize(graph)
-		@graph = graph
-	  end
-
-	  def tag_start(name, attrs)
-		case name
-		when 'edge'
-		  @graph.add_edge(attrs['source'],
-						  attrs['target'])
-		when 'node'
-		  @graph.add_vertex(attrs['id'])
-		end
-	  end
-	end
-	
-	def MutableGraph.append_features(includingClass)
-	  super
-
-	  # Create a new MutableGraph from the XML-Source _source_.
-	  def includingClass.from_graphxml (source)
-		listener = MutableGraphParser.new(self.new)
-		REXML::Document.parse_stream(source, listener)
-		listener.graph
-	  end
-	end
-  end
-end
+
+    class MutableGraphParser
+
+      include REXML::StreamListener
+
+      attr_reader :graph
+
+      def initialize (graph)
+        @graph = graph
+      end
+
+      def tag_start (name, attrs)
+        case name
+        when 'edge'
+          @graph.add_edge(attrs['source'], attrs['target'])
+        when 'node'
+          @graph.add_vertex(attrs['id'])
+        end
+      end
+
+    end		# class MutableGraphParser
+        
+    def MutableGraph.append_features (includingClass)
+      super
+
+      # Create a new MutableGraph from the XML-Source _source_.
+
+      def includingClass.from_graphxml (source)
+        listener = MutableGraphParser.new(self.new)
+        REXML::Document.parse_stream(source, listener)
+        listener.graph
+      end
+    end
+
+  end                           # module GraphXML
+end                             # module RGL