rgl 0.2.2

data/lib/rgl/connected_components.rb

@@ -0,0 +1,125 @@
+# 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).
+#
+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
+            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

data/lib/rgl/dot.rb

@@ -0,0 +1,63 @@
+# 
+# $Id: dot.rb,v 1.4 2002/11/13 21:53:27 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.
+
+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")
+      src = dotfile + ".dot"
+      dot = dotfile + "." + fmt
+      
+      File.open(src, 'w') do |f|
+        f << self.to_dot_graph.to_s << "\n"
+      end
+      
+      system( "dot -T#{fmt} #{src} -o #{dot}" )
+      dot
+    end
+  end
+end

data/lib/rgl/graphxml.rb

@@ -0,0 +1,52 @@
+# This file contains minimal support for creating RGL graphs from the GraphML
+# 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).
+#
+# We use REXML::StreamListener from the REXML library
+# (http://www.germane-software.com/software/rexml) to parse the grapml files.
+
+require 'rgl/mutable'
+require 'rexml/document'
+require 'rexml/streamlistener'
+
+module RGL
+  # 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.
+  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

data/lib/rgl/implicit.rb

@@ -0,0 +1,151 @@
+# This file contains the definition of the class RGL::ImplicitGraph which
+# defines vertex and edge iterators using blocks (which again call blocks).
+# 
+# An ImplicitGraph provides a handy way to define graphs on the fly using two
+# blocks for the two iterators defining a graph. The directed cyclic graph with
+# 5 vertices can be created as follows:
+#
+#   g = RGL::ImplicitGraph.new { |g|
+# 	  g.vertex_iterator { |b| 0.upto(4,&b) }
+# 	  g.adjacent_iterator { |x, b| b.call((x+1)%5) }
+# 	  g.directed = true
+#   }
+#   g.to_s => "(0-1)(1-2)(2-3)(3-4)(4-0)"
+#
+# Other examples are given by the methods vertices_filtered_by and
+# edges_filtered_by, which can be applied to any graph.
+require 'rgl/base'
+
+module RGL
+  class ImplicitGraph
+	include Graph
+
+	attr_writer :directed
+
+	EMPTY_VERTEX_ITERATOR = proc { |b| }
+	EMPTY_NEIGHBOR_ITERATOR = proc { |x, b| }
+	
+	# Create a new ImplicitGraph, which is by default empty. The caller should
+	# configure the with vertex and neighbor iterators. If the graph is directed
+	# the client should set directed to true. The default value for _directed_
+	# is false. 
+	def initialize
+	  @directed = false
+	  @vertex_iterator = EMPTY_VERTEX_ITERATOR
+	  @adjacent_iterator = EMPTY_NEIGHBOR_ITERATOR
+	  yield self if block_given?				# let client overwrite defaults
+	end
+
+	# Returns the value of @directed.
+	def directed?; @directed; end
+	
+	def each_vertex (&block)	# :nodoc:
+	  @vertex_iterator.call(block)
+	end
+
+	def each_adjacent (v, &block) # :nodoc:
+	  @adjacent_iterator.call(v,block)
+	end
+
+	def each_edge (&block) # :nodoc:
+	  if defined? @edge_iterator
+		@edge_iterator.call(block)
+	  else
+		super					# use default implementation
+	  end
+	end
+
+	# Sets the vertex_iterator to _block_ which must be a block of one parameter
+	# which again is the block called by each_vertex.
+	def vertex_iterator (&block)
+	  @vertex_iterator = block
+	end
+
+	# Sets the adjacent_iterator to _block_ which must be a block of two
+	# parameters: 
+	# The first parameter is the vertex the neighbors of which are to be
+	# traversed. The second is the block which will be called for each neighbor
+	# of this vertex.
+	def adjacent_iterator (&block)
+	  @adjacent_iterator = block
+	end
+
+	# Sets the edge_iterator to _block_ which must be a block of two parameters:
+	# The first parameter is the source of the edges an the second is the target
+	# of the edge.
+	def edge_iterator (&block)
+	  @edge_iterator = block
+	end
+  end
+
+  module Graph
+	# ---
+	# === Graph adaptors
+	#
+	# Return a new ImplicitGraph which has as vertices all vertices of the
+	# receiver which satisfy the predicate _filter_.
+	#
+	# The methods provides similar functionaty as the BGL graph adapter
+	# filtered_graph (see BOOST_DOC/filtered_graph.html). 
+	#
+	# ==== Example
+	#
+	# 	def complete (n)
+	# 	  set = n.integer? ? (1..n) : n
+	# 	  RGL::ImplicitGraph.new { |g|
+	# 		g.vertex_iterator { |b| set.each(&b) }
+	# 		g.adjacent_iterator { |x, b|
+	# 		  set.each { |y| b.call(y) unless x == y }
+	# 		}
+	# 	  }
+	# 	end
+	#
+	# 	complete(4).to_s =>	"(1=2)(1=3)(1=4)(2=3)(2=4)(3=4)"
+	# 	complete(4).vertices_filtered_by {|v| v != 4}.to_s => "(1=2)(1=3)(2=3)"
+	def vertices_filtered_by (&filter)
+	  implicit_graph {|g|
+		g.vertex_iterator { |b|
+		  self.each_vertex { |v| b.call(v) if filter.call(v) }
+		}
+		g.adjacent_iterator { |v, b|
+		  self.each_adjacent(v) { |u| b.call(u) if filter.call(u) }
+		}
+	  }
+	end
+
+	# Return a new ImplicitGraph which has as edges all edges of the receiver
+	# which satisfy the predicate _filter_ (a block with to parameters).
+	#
+	# ==== Example
+	#
+	# 	g = complete(7).edges_filtered_by {|u,v| u+v == 7}
+	#	g.to_s => "(1=6)(2=5)(3=4)"
+	#	g.vertices => [1, 2, 3, 4, 5, 6, 7]
+	def edges_filtered_by (&filter)
+	  implicit_graph {
+		|g|
+		g.adjacent_iterator { |v, b|
+		  self.each_adjacent(v) { |u|
+			b.call(u) if filter.call(v,u)
+		  }
+		}
+		g.edge_iterator { |b|
+		  self.each_edge {|u,v| b.call(u,v) if filter.call(u,v)}
+		}
+	  }
+	end
+
+	# Return a new ImplicitGraph which is isomorphic (i.e. has same edges and
+	# vertices) to the receiver. It is a shortcut also used by
+	# edges_filtered_by and vertices_filtered_by.
+	def implicit_graph
+	  result = ImplicitGraph.new {|g|
+		g.vertex_iterator { |b| self.each_vertex(&b)}
+		g.adjacent_iterator { |v, b| self.each_adjacent(v,&b)}
+		g.directed = self.directed?
+	  }
+	  yield result if block_given? # let client overwrite defaults
+	  result
+	end
+  end							# module Graph
+end

data/lib/rgl/mutable.rb

@@ -0,0 +1,54 @@
+require 'rgl/base'
+
+module RGL
+  # A MutableGraph can be changed via the addition or removal of edges and
+  # vertices. 
+  module MutableGraph
+	include Graph
+
+	# Add a new vertex _v_ to the graph. If the vertex is already in (using
+	# eql?) the method does nothing.
+	def add_vertex(v); raise NotImplementedError; end
+
+	# Inserts the edge (u,v) into the graph.
+	#
+	# Note that for undirected graphs, (u,v) is the same edge as (v,u), so after
+	# a call to the function add_edge(), this implies that edge (u,v) will
+	# appear in the out-edges of u and (u,v) (or equivalently (v,u)) will appear
+	# in the out-edges of 
+	# v. Put another way, v will be adjacent to u and u will be adjacent to v. 
+	def add_edge(u, v); raise NotImplementedError; end
+
+	# Add all objects in _a_ to the vertex set.
+	def add_vertices (*a)
+	  a.each {|v| add_vertex v}
+	end
+
+	# Add all edges in the _edges_ array to the edge set. Element of the array
+	# can be both two element arrays or instances of DirectedEdge or
+	# UnDirectedEdge. 
+	def add_edges (*edges)
+	  edges.each {|edge| add_edge(edge[0],edge[1])}
+	end
+
+	# Remove u from the vertex set of the graph. All edges who's target is _v_
+	# are also removed from the edge set of the graph.
+	#
+	# Postcondition: num_vertices is one less, _v_ no longer appears in the
+	# vertex set of the graph and there no edge with source or target _v_.
+	def remove_vertex(v); raise NotImplementedError; end
+
+	# Remove the edge (u,v) from the graph. If the graph allows parallel edges
+	# this remove all occurrences of (u,v).
+	# 
+	# Precondition: u and v are vertices in the graph.
+	# Postcondition: (u,v) is no longer in the edge set for g.
+	def remove_edge(u, v); raise NotImplementedError; end
+
+	# Remove all vertices specified by the array a from the graph calling
+	# remove_vertex.
+	def remove_vertices (*a)
+	  a.each {|v| remove_vertex v}
+	end
+  end
+end