rgl 0.2.2

data/install.rb

@@ -0,0 +1,49 @@
+#! /usr/bin/env ruby
+
+require 'getoptlong'
+require 'rbconfig'
+require 'ftools'
+require 'find'
+
+SRC_BASE = 'lib'
+SRC = 'rgl'
+
+
+INSTDIR = File.join Config::CONFIG['sitedir']
+DESTDIR = File.join INSTDIR, SRC
+
+opts = GetoptLong.new( [ "--uninstall",	"-u",		GetoptLong::NO_ARGUMENT ] )
+
+def install
+  begin
+    File.makedirs( DESTDIR )
+    pwd = Dir.pwd
+    Dir.chdir(SRC_BASE)
+	Dir['*.rb'].each do |file|
+      dst = File.join( INSTDIR, file )
+      File.install(file, dst, 0644, true)
+    end
+    Find.find(SRC) do |file|
+      dst = File.join( INSTDIR, file )
+      File.install(file, dst, 0644, true) if file =~ /.rb$/
+    end
+    Dir.chdir(pwd)
+  rescue
+    puts $!
+  end
+end
+
+def uninstall
+  begin
+    puts "Deleting:"
+    Find.find(DESTDIR) { |file| File.rm_f file,true }
+    Dir.delete DESTDIR
+  rescue
+  end
+end
+
+if (opt = opts.get) and opt[0] =~ /^-?-u/
+  uninstall
+else
+  install
+end

data/lib/rgl/adjacency.rb

@@ -0,0 +1,151 @@
+# 
+# $Id: adjacency.rb,v 1.4 2002/11/10 21:21:20 monora Exp $
+# 
+# The DirectedAdjacencyGraph class implements a generalized adjacency list
+# graph structure. An AdjacencyGraph is basically a two-dimensional structure,
+# where each element of the first dimension represents a vertex, and each of
+# the vertices contains a one-dimensional structure that is the list of all
+# adjacent vertices.
+#
+# The class for representing the adjacency list of a vertex is by default a
+# Set, but can be configured by the client when a AdjacencyGraph is created.
+
+require 'rgl/mutable'
+require 'set'
+
+module RGL
+  class DirectedAdjacencyGraph
+	include MutableGraph
+
+	# Shortcut for creating a DirectedAdjacencyGraph:
+	#
+	#  RGL::DirectedAdjacencyGraph[1,2, 2,3, 2,4, 4,5].edges.to_a.to_s =>
+	#    "(1-2)(2-3)(2-4)(4-5)"
+	def self.[](*a)
+	  result = new
+	  0.step(a.size-1,2) { |i| result.add_edge(a[i],a[i+1])}
+	  result
+	end
+
+	# Returns a new empty DirectedAdjacencyGraph which has as edgelist class the
+	# given class. The default edgelist class is Set to ensure set semantics for
+	# edges and vertices.
+	def initialize(edgelist_class=Set)
+	  @edgelist_class = edgelist_class
+	  @vertice_dict = Hash.new
+	end
+
+	# Iterator for the keys of the vertice list hash.
+	def each_vertex(&b)
+	  @vertice_dict.each_key(&b)
+	end
+
+	def each_adjacent(v, &b)	# :nodoc:
+	  adjacency_list = @vertice_dict[v] or raise NoVertexError, "No vertex #{v}."
+	  adjacency_list.each(&b)
+	end
+
+	# Returns true.
+	def directed?; true; end
+
+	# Complexity is O(1), since the vertices are kept in a Hash containing as
+	# value the list of adjacent vertices of _v_.
+	def has_vertex?(v); @vertice_dict.has_key?(v); end
+
+	# Complexity is O(1), if a Set is used as adjacency list, otherwise
+	# O(out_degree(v)) 
+	#
+	# ---
+	# MutableGraph interface.
+	def has_edge? (u, v)
+	  has_vertex?(u) and @vertice_dict[u].include? v
+	end
+
+	# See MutableGraph#add_vertex.
+	#
+	# If the vertex is already in (using eql?) the method does nothing.
+	def add_vertex(v)
+	  @vertice_dict[v] ||= @edgelist_class.new
+	end
+
+	# See MutableGraph#add_edge.
+	def add_edge (u,v)
+	  add_vertex(u)				# ensure key
+	  add_vertex(v)				# ensure key
+	  basic_add_edge(u,v)
+	end
+
+	# See MutableGraph#remove_vertex.
+	def remove_vertex(v)
+	  @vertice_dict.delete(v)
+	  
+	  # remove v from all adjacency lists
+	  @vertice_dict.each_value { |adjList| adjList.delete(v) }
+	end
+
+	# See MutableGraph::remove_edge.
+	def remove_edge (u,v)
+	  @vertice_dict[u].delete(v) unless @vertice_dict[u].nil?
+	end
+
+	protected
+
+	def basic_add_edge(u,v)
+	  @vertice_dict[u].add v
+	end
+  end							# class AdjacencyGraph
+
+  # AdjacencyGraph is an undirected Graph. The methods add_edge and remove_edge
+  # are reimplemented: If an edge (u,v) is added or removed then the reverse
+  # edge (v,u) is also added or removed.
+  class AdjacencyGraph < DirectedAdjacencyGraph
+	# Always returns false.
+	def directed?; false; end
+	
+	# Also removes (v,u)
+	def remove_edge (u,v)
+	  super
+	  @vertice_dict[v].delete(u) unless @vertice_dict[v].nil?
+	end
+
+	protected
+	def basic_add_edge(u,v)
+	  super
+	  # Insert backwards edge
+	  @vertice_dict[v].add u
+	end
+  end
+
+  module Graph
+	# Convert a general graph to an AdjacencyGraph. If the graph is directed
+	# returns a DirectedAdjacencyGraph else a AdjacencyGraph.
+	def to_adjacency
+	  result = (directed? ? DirectedAdjacencyGraph : AdjacencyGraph).new
+	  each_edge { |u,v| result.add_edge u,v }
+	  result
+	end
+
+	# Return a new DirectedAdjacencyGraph which has the same set of vertices. If
+	# (u,v) is an edge of the graph then (v,u) is an edge of the result.
+	#
+	# If the graph is undirected the result is self.
+	def reverse
+	  reurn self unless directed?
+	  result = DirectedAdjacencyGraph.new
+	  each_edge { |u,v| result.add_edge v,u }
+	  result
+	end
+
+	# Return a new AdjacencyGraph which has the same set of vertices. If (u,v)
+	# is an edge of the graph (u,v) and (v,u) (which are the same edges) is an
+	# edge of the result.
+	#
+	# If the graph is undirected the result is self.
+	def to_undirected
+	  return self unless directed?
+	  result = AdjacencyGraph.new
+	  each_edge { |u,v| result.add_edge u,v }
+	  result
+	end
+  end
+end

data/lib/rgl/base.rb

@@ -0,0 +1,299 @@
+# :include: ../../README
+#
+# ----
+#
+# Module RGL defines the namespace for all modules and classes of the graph
+# library. The main module is RGL::Graph which defines the abstract behavior of
+# all graphs in the library.
+
+RGL_VERSION = "0.2.2"
+
+unless Enumerable.instance_methods(true).grep(/inject/)
+  module Enumerable
+	def inject(*argv)
+	  argc = argv.size
+
+	  if argc == 0
+		first = true
+		result = nil
+
+		each { |e|
+		  if first
+			first = false
+			result = e
+		  else
+			result = yield(result, e)
+		  end
+		}
+	  elsif argc == 1
+		result = argv[0]
+
+		each { |e| result = yield(result, e) }
+	  else
+		raise ArgumentError, "wrong # of arguments(#{argc} for 1)"
+	  end
+
+	  result
+	end
+  end
+end  
+
+module Enumerable
+  # Fixnum()
+  #
+  # Return the number of elements of the Enumerable. Same as _size_ but not all
+  # Enumerables implement size.
+  #--
+  # Should we call the methods _size_?
+  def length
+	inject(0) do |sum,v|
+	  sum + 1
+	end
+  end
+end
+
+module RGL
+  class NotDirectedError < RuntimeError; end
+  class NotUndirectedError < RuntimeError; end
+
+  class NoVertexError < IndexError; end
+  class NoEdgeError < IndexError; end
+
+  # Module Edge includes classes for representing egdes of directed and
+  # undirected graphs. There is no need for a Vertex class, because every ruby
+  # object can be a vertex of a graph.
+  module Edge
+	# Simply a directed pair (source -> target). Must library functions try do
+	# omit to instantiate edges. They instead use two vertex parameters for
+	# representing edges (see each_edge). If a client wants to store edges
+	# explicitly DirecteEdge or UnDirectedEdge instances are return
+	# (i.e. Graph#edges). 
+	class DirectedEdge
+	  attr_accessor :source, :target
+
+	  # Can be used to create an edge from a two element array.
+	  def self.[](*a)
+		new(a[0],a[1])
+	  end
+
+	  # Create a new DirectedEdge with source _a_ and target _b_.
+	  def initialize (a,b)
+		@source, @target = a,b
+	  end
+	  
+	  # Two directed edges (u,v) and (x,y) are equal iff u == x and v == y. eql?
+	  # is needed when edges are inserted into a Set. eql? is aliased to ==.
+	  def eql?(edge)
+		source == edge.source and target == edge.target
+	  end
+	  alias == eql?
+
+	  # Returns (v,u) if self == (u,v).
+	  def reverse
+		self.class.new(target, source)
+	  end
+
+	  # Edges can be indexed. edge[0] == edge.source, edge[n] == edge.target for
+	  # all n>0. Edges can thus be used as a two element array.
+	  def [](index); index.zero? ? source : target; end
+
+	  # DirectedEdge[1,2].to_s == "(1-2)"
+	  def to_s
+		"(#{source}-#{target})"
+	  end
+	  # Returns the array [source,target].
+	  def to_a; [source,target]; end
+
+	  # Sort support is dispatched to the <=> method of Array
+	  def <=> e
+		self.to_a <=> e.to_a
+	  end
+	end							# DirectedEdge
+
+	# An undirected edge is simply an undirected pair (source, target) used in
+	# undirected graphs. UnDirectedEdge[u,v] == UnDirectedEdge[v,u]
+	class UnDirectedEdge < DirectedEdge
+	  def eql?(edge)
+		super or (target == edge.source and source == edge.target)
+	  end
+	  
+	  def hash
+		source.hash ^ target.hash
+	  end
+	  
+	  # UnDirectedEdge[1,2].to_s == "(1=2)"
+	  def to_s; "(#{source}=#{target})"; end
+	end
+  end							# Edge
+
+  # In BGL terminology the module Graph defines the concept graph (see
+  # BOOST_DOC/graph_concepts.html). We though do not
+  # distinguish between IncidenceGraph, EdgeListGraph and VertexListGraph
+  # concept, which would complicate
+  # the interface two much. These concepts are defined in BGL to differentiate
+  # between efficient access to edges and vertices.
+  # 
+  # The RGL Graph concept contains only few requirements that are common to all
+  # the graph
+  # concepts. These include especially the iterators defining the set of
+  # vertices and edges (see each_vertex and each_adjacent). Most other functions
+  # are derived from these fundamental iterators, i.e. num_vertices() or
+  # num_edges(). 
+  #
+  # Each graph is an enumerable of vertices.
+  module Graph
+	include Enumerable
+	include Edge
+
+	# The each_vertex iterator defines the set of vertices. This method must be 
+	# defined be concrete graph classes. It defines the BGL VertexListGraph
+	# concept.
+	def each_vertex
+	  raise NotImplementedError
+	  yield v					# for RDoc
+	end
+
+	# The each_adjacent iterator defines the out edges of vertex _v_. This
+	# method must be defined be concrete graph classes. Its defines the BGL
+	# IncidenceGraph concept.
+	def each_adjacent (v)
+	  raise NotImplementedError
+	  yield u					# for RDoc
+	end
+
+	# The each_edge iterator should provide efficient access to all edges of the
+	# graph. Its defines the EdgeListGraph concept.
+	#
+	# This method must _not_ be defined be concrete graph classes, because it
+	# can be implemented using each_vertex and each_adjacent. However for
+	# undirected graph the function is inefficient because we must may not yield
+	# (v,u) if we already visited edge (u,v).
+	def each_edge (&block)
+	  if directed?
+		each_vertex { |u|
+		  each_adjacent(u) { |v| yield u,v }
+		}
+	  else
+		each_edge_aux(&block)		# concrete graphs should to this better
+	  end
+	end
+	
+	# Vertices get enumerated. A graph is thus an enumerable of vertices.
+	# ---
+	# === Testing
+	def each(&block); each_vertex(&block); end
+	
+	# Is the graph directed? The default returns false.
+	def directed?; false; end
+
+	# Returns true if _v_ is a vertex of the graph. Same as include? inherited
+	# from enumerable. Complexity is O(num_vertices) by default. Concrete graph
+	# may bee better here (see AdjacencyGraph).
+	def has_vertex?(v); include?(v); end	# inherited from enumerable
+
+	# Returns true if the graph has no vertex, i.e. num_vertices == 0.
+	# ---
+	# === accessing vertices and edges
+	def empty?; num_vertices.zero?; end
+
+	# Return the array of vertices. Synonym for to_a inherited by enumerable.
+	def vertices; to_a; end
+
+	# Returns the class for edges: DirectedEdge or UnDirectedEdge.
+	def edge_class; directed? ? DirectedEdge : UnDirectedEdge; end
+
+	# Return the array of edges (DirectedEdge or UnDirectedEdge) of the graph
+	# using each_edge, depending whether the graph is directed or not.
+	def edges
+	  result = []
+	  c = edge_class
+	  each_edge { |u,v| result << c.new(u,v) }
+	  result
+	end
+
+	# Returns an array of vertices adjacent to vertex _v_.
+	def adjacent_vertices (v)
+	  r = []
+	  each_adjacent(v) {|u| r << u}
+	  r
+	end
+
+	# Returns the number of out-edges (for directed graphs) or the number of incident
+	# edges (for undirected graphs) of vertex _v_.
+	def out_degree (v)
+	  r = 0
+	  each_adjacent(v) { |u| r += 1}
+	  r
+	end
+
+	# Returns the number of vertices.
+	def size # Why not in Enumerable?
+	  #inject(0) { |n, v| n + 1 } # inject not yet available in Enumerable!
+	  r = 0; each_vertex {|v| r +=1}; r
+	end
+
+	# Synonym for size.
+	def num_vertices; size; end
+
+	# Returns the number of edges.
+	def num_edges; r = 0; each_edge {|u,v| r +=1}; r; end
+
+	# Utility method to show a string representation of the edges of the graph.
+	def to_s
+	  edges.sort.to_s
+	end
+
+	private
+	
+	def each_edge_aux
+	  # needed in each_edge
+	  visited = Hash.new
+	  each_vertex { |u|
+		each_adjacent(u) { |v|
+		  edge = UnDirectedEdge.new u,v
+		  unless visited.has_key? edge
+			visited[edge]=true
+			yield u, v
+		  end
+		}
+	  }
+	end
+  end							# module Graph
+
+  # BGL defines the concept BidirectionalGraph as follows:
+  # 
+  # The BidirectionalGraph concept refines IncidenceGraph and adds the
+  # requirement  for efficient access to the in-edges of each vertex. This
+  # concept is separated from IncidenceGraph because for directed graphs
+  # efficient access to in-edges typically requires more storage space, and many
+  # algorithms do not require access to in-edges. For undirected graphs this is
+  # not an issue, since the in_edges() and out_edges() functions are the same,
+  # they both return the edges incident to the vertex.
+  module BidirectionalGraph
+	include Graph
+
+	# Iterator providing access to the in-edges (for directed graphs) or incident
+	# edges (for undirected graphs) of vertex _v_. For both directed and
+	# undirected graphs, the target of an out-edge is required to be vertex _v_
+	# and the source is required to be a vertex that is adjacent to _v_.
+	def each_in_neighbor (v)
+	  raise NotImplementedError
+	  yield u
+	end
+	
+	# Returns the number of in-edges (for directed graphs) or the number of
+	# incident edges (for undirected graphs) of vertex _v_.
+	def in_degree (v)
+	  r = 0;
+	  each_in_neighbor(v) { |u| r += 1}
+	  r
+	end
+
+	# Returns the number of in-edges plus out-edges (for directed graphs) or the 
+	# number of incident edges (for undirected graphs) of vertex _v_.
+	def degree (v)
+	  in_degree(v) + out_degree(v)
+	end
+  end
+end								# module RGL
+