rgl 0.2.3 → 0.3.0

data/README

@@ -83,7 +83,7 @@ The concepts of IncidenceGraph, AdjacencyGraph and VertexListGraph (see
 http://www.boost.org/libs/graph/doc/IncidenceGraph.html) are here bundled in the
 base graph module. Most methods of IncidenceGraph should be standard in the base
 module Graph. The complexity guarantees can not necessarily provided.  See
-http://www.boost.org/libs/graph/doc/graph_concepts.html
+http://www.boost.org/libs/graph/doc/graph_concepts.html.
 
 == Installation
 
@@ -102,7 +102,7 @@ or directly with
 
   % gem install rgl
 
-Use the correct version number for VERSION (e.g. 0.2.2).  You may need root
+Use the correct version number for VERSION (e.g. 0.2.x).  You may need root
 privileges to install.
 
 === Running tests
@@ -112,23 +112,27 @@ installation directory and start rake:
 
  % gem env
  Rubygems Environment:
-  - VERSION: 0.8.3 (0.8.3)
+  - VERSION: 0.9.0 (0.9.0)
   - INSTALLATION DIRECTORY: /usr/lib/ruby/gems/1.8
   - GEM PATH:
      - /usr/lib/ruby/gems/1.8
   - REMOTE SOURCES:
      - http://gems.rubyforge.org
 
- % cd /usr/lib/ruby/gems/1.8/gems/rgl-0.2.2/
- % r40> rake
-  (in /usr/lib/ruby/gems/1.8/gems/rgl-0.2.2)
-  ruby1.8 -Ilib:tests -e0  -rtests/TestGraphXML  -rtests/TestComponents  -rtests/TestDirectedGraph  -rtests/TestEdge  -rtests/TestImplicit  -rtests/TestTransitiveClosure  -rtests/TestTraversal  -rtests/TestUnDirectedGraph
- Loaded suite -e
+ % cd /usr/lib/ruby/gems/1.8/gems/rgl-0.3.0/
+ % rake
+ (in /usr/lib/ruby/gems/1.8/gems/rgl-0.3.0)
+ /usr/bin/ruby1.8 -Ilib:tests "/usr/lib/ruby/gems/1.8/gems/rake-0.7.3/lib/rake/rake_test_loader.rb" "tests/TestTransitiveClosure.rb" "tests/TestComponents.rb" "tests/TestCycles.rb" "tests/TestDirectedGraph.rb" "tests/TestEdge.rb" "tests/TestGraph.rb" "tests/TestGraphXML.rb" "tests/TestImplicit.rb" "tests/TestUnDirectedGraph.rb" "tests/TestTraversal.rb" "tests/TestDot.rb" "tests/TestRdot.rb" 
+ Loaded suite /usr/lib/ruby/gems/1.8/gems/rake-0.7.3/lib/rake/rake_test_loader
  Started
- ........................................................................................................
- Finished in 0.736444 seconds.
+ ......................................................................................................................................................
+ Finished in 0.750958 seconds.
 
- 40 tests, 421 assertions, 0 failures, 0 errors
+ 86 tests, 625 assertions, 0 failures, 0 errors
+ 
+=== Code coverage
+
+Running rcov[http://eigenclass.org/hiki.rb?rcov] on the test suite generates this[link:coverage/index.html] result.
 
 === Normal Installation
 
@@ -137,7 +141,9 @@ following command:
 
   % ruby install.rb
 
-from its distribution directory.
+from its distribution directory. To uninstall it use
+
+  % ruby install.rb -u
 
 == Example irb session with RGL
 
@@ -185,7 +191,7 @@ Add inverse edge (4-2) to directed graph:
 
 <em>Topological sort</em> is realized with as iterator:
 
-  require 'graph/topsort'
+  require 'rgl/topsort'
   irb> dg.topsort_iterator.to_a
   [1, 2, 3, 6, 4, 5]
 
@@ -227,12 +233,16 @@ produces module_graph.jpg: link:../examples/module_graph.jpg
 Look for more in the examples directory (i.e.
 examples.rb[link:files/examples/examples_rb.html]).
 
+== My del.icio.us links concerning RGL
+
+I collect some links to stuff around RGL at http://del.icio.us/monora/rgl. I
+registered RGL at SWiK[http://swik.net/rgl].
+
 == Credits
 
 Many thanks to Robert Feldt which also worked on a graph library
 (http://rockit.sf.net/subprojects/graphr) who pointed me to BGL and many other
-graph resources. Manuel Simoni found a subtle bug in a preliminary version
-announced at http://rubygarden.com/ruby?RubyAlgorithmPackage/Graph.
+graph resources.
 
 Robert kindly allowed to integrate his work on graphr, which I did not yet
 succeed. Especially his work to output graphs for
@@ -249,15 +259,17 @@ and matz for Ruby. Dave included in the latest version of RDoc (alpha9) the
 module dot/dot.rb which I use instead of Roberts module to visualize graphs
 (see rgl/dot.rb).
 
+Jeremy Bopp, John Carter, Sascha Doerdelmann and Shawn Garbett for contributing
+additions, test cases and bugfixes.
+
 == Copying
 
-RGL is Copyright (c) 2002,2004,2005 by Horst Duchene.  It is free software, and may be
-redistributed under the terms specified in the README file of the Ruby
-distribution.
+RGL is Copyright (c) 2002,2004,2005,2008 by Horst Duchene.  It is free software, and may be
+redistributed under the terms specified in the README file of the Ruby distribution.
 
 == Support
 
-Please contact me at mailto:monora@users.sourceforge.net with bug reports
+Please contact me at mailto:monora@gmail.com with bug reports
 suggestions, and other comments. If you send patches, it would help if
 they were in-line (not attachments) and generated using "diff -u".
 

data/Rakefile

@@ -11,15 +11,16 @@ require 'rake/testtask'
 require 'rake/rdoctask'
 
 # Determine the current version of the software
-
-if `ruby -Ilib -rrgl/base -e'puts RGL_VERSION'` =~ /\S+$/
-  PKG_VERSION = $&
+rgl_version =
+if %x(ruby -Ilib -rrgl/base -e'puts RGL_VERSION') =~ /\S+$/
+  $&
 else
-  PKG_VERSION = "0.0.0"
+  "0.0.0"
 end
 
 SUMMARY = "Ruby Graph Library"
 SOURCES = FileList['lib/**/*.rb']
+CLOBBER.include('TAGS', 'coverage')
 RDOC_DIR = './rgl'
 
 # The default task is run if rake is given no explicit arguments.
@@ -41,9 +42,18 @@ task :test
 desc "Run all test targets"
 task :testall => [:test ]
 
+desc "Do code coverage with rcov"
+task :rcov do
+  begin 
+    sh 'rcov -Ilib:tests --exclude "tests/.*[tT]est.*.rb,usr.local" tests/Test*rb'
+  rescue Exception
+    nil
+  end
+end
+
 # Install rgl using the standard install.rb script.
 
-desc "Install the application"
+desc "Install the library"
 task :install do
   ruby "install.rb"
 end
@@ -52,23 +62,26 @@ end
 
 desc "Tag all the CVS files with the latest release number (TAG=x)"
 task :tag do
-  rel = "REL_" + PKG_VERSION.gsub(/\./, '_')
+  rel = "REL_" + rgl_version.gsub(/\./, '_')
   rel << ENV['TAG'] if ENV['TAG']
   puts rel
   sh %{cvs commit -m 'pre-tag commit'}
   sh %{cvs tag #{rel}}
 end
 
+desc "Accumulate changelog"
+task :changelog do
+  sh %{cvs2cl --tags --utc --prune --accum}
+end
+
 # Create a task to build the RDOC documentation tree.
 
 rd = Rake::RDocTask.new("rdoc") { |rdoc|
   rdoc.rdoc_dir = RDOC_DIR
-#  rdoc.template = 'kilmer'
-#  rdoc.template = 'css2'
+  rdoc.template = 'doc/jamis.rb'
   rdoc.title    = SUMMARY
-  rdoc.options << '--line-numbers' << '--inline-source' <<
-     '--main' << 'README'
-  rdoc.rdoc_files.include(SOURCES, 'README', 'examples/examples.rb')
+  rdoc.options << '--line-numbers' << '--inline-source' << '--main' << 'README'
+  rdoc.rdoc_files.include(SOURCES, 'README', 'ChangeLog', 'examples/examples.rb', 'rakelib/*.rake')
 }
 
 # ====================================================================
@@ -79,30 +92,27 @@ PKG_FILES = FileList[
   'install.rb',
   '[A-Z]*',
   'tests/**/*.rb',
-  'examples/**/*'
+  'examples/**/*',
+  'rakelib/*.rake'
 ] + SOURCES
 
 if ! defined?(Gem)
-  puts "Package Target requires RubyGEMs"
+  puts "Package Target requires RubyGems"
 else
   spec = Gem::Specification.new do |s|
     
-    #### Basic information.
-
     s.name = 'rgl'
-    s.version = PKG_VERSION
+    s.version = rgl_version
     s.summary = SUMMARY
-
+    
     s.description = <<-EOF
     RGL is a framework for graph data structures and algorithms.
 
     The design of the library is much influenced by the Boost Graph Library (BGL)
     which is written in C++ heavily using its template mechanism.
 
-
     RGL currently contains a core set of algorithm patterns:
 
-
      * Breadth First Search 
      * Depth First Search 
 
@@ -114,37 +124,39 @@ else
      * Connected Components 
      * Strongly Connected Components 
      * Transitive Closure
+     * Search cycles (contributed by Shawn Garbett)
     EOF
-
+    
     #### Dependencies and requirements.
-
+    
     s.add_dependency('stream', '>= 0.5')
+    s.add_dependency 'rake'
     s.requirements << "Stream library, v0.5 or later"
-
+    
     #### Which files are to be included in this gem?  Everything!  (Except CVS directories.)
     s.files = PKG_FILES.to_a
-
+    
     #### Load-time details: library and application (you will need one or both).
-
+    
     s.require_path = 'lib'                         # Use these for libraries.
     s.autorequire = 'rgl/base'
-
+    
     #### Documentation and testing.
-
+    
     s.has_rdoc = true
     s.extra_rdoc_files = ['README']
     s.rdoc_options <<
       '--title' <<  'RGL - Ruby Graph Library' <<
       '--main' << 'README' <<
       '--line-numbers'
-
+    
     #### Author and project details.
     s.author = "Horst Duchene"
-    s.email = "hd.at.clr@hduchene.de"
+    s.email = "monora@gmail.com"
     s.homepage = "http://rgl.rubyforge.org"
     s.rubyforge_project = "rgl"
   end
-
+  
   Rake::GemPackageTask.new(spec) do |pkg|
     #pkg.need_zip = true
     pkg.need_tar = true
@@ -197,14 +209,9 @@ task :lines do
   show_line("TOTAL", total_lines, total_code)
 end
 
-ARCHIVEDIR = '/mnt/flash'
-
-task :archive => [:package] do
-  cp FileList["pkg/*.tgz", "pkg/*.zip", "pkg/*.gem"], ARCHIVEDIR
-end
-
 desc "Copy rdoc html to rubyforge"
-task :rdoc2rf => [:rdoc] do
+task :rdoc2rf => [:rdoc, :rcov, :changelog] do
+  mv 'coverage', RDOC_DIR
   sh "scp -r #{RDOC_DIR} monora@rubyforge.org:/var/www/gforge-projects/rgl"
   sh "scp examples/*.jpg monora@rubyforge.org:/var/www/gforge-projects/rgl/examples"
 end

data/examples/{insel.rb → insel-der-tausend-gefahren.rb}

@@ -1,4 +1,5 @@
-# Some graph examples
+# Die Insel der 1000 Gefahren
+# http://www.amazon.de/1000-Gefahren-Die-Insel/dp/3473520225/ref=pd_sim_b?ie=UTF8&qid=1203279845&sr=8-3
 
 require 'rubygems' rescue nil
 require 'rgl/adjacency'
@@ -134,8 +135,56 @@ g = RGL::DirectedAdjacencyGraph[
   53, 91,
 
   55, 93,
-  55, 94
+  55, 94, 
 
-]
-g.dotty
+  
+  57,  92,
+
+
+  58, 97,
+  58, 98,
+
+  59, 99,
+  99, 100,
+
+  60, 100,
+
+
+  61, 101,
+  61, 102,
+  61, 103,
+
+  62, 104,
+  62, 105, 
+
+  64, 88,
+
+  65, 106,
+  65, 107,
 
+  66, 9,
+
+  67, 108,
+  67, 109,
+
+  75, 9,
+  
+  78, 26,
+
+  86, 30,
+
+  88, 106,
+  88, 89,
+
+  89, 16,
+
+  92, 95,
+  92, 96,
+
+  93, 37,
+
+  96, 9,
+
+  105, 9,
+  105, 10]
+g.dotty

data/lib/rgl/adjacency.rb

@@ -1,6 +1,6 @@
 # adjacency.rb
 # 
-# $Id: adjacency.rb,v 1.7 2005/03/30 21:25:34 monora Exp $
+# $Id: adjacency.rb,v 1.11 2008/03/02 13:45:43 monora Exp $
 # 
 # The DirectedAdjacencyGraph class implements a generalized adjacency list
 # graph structure.  An AdjacencyGraph is basically a two-dimensional structure
@@ -35,10 +35,24 @@ module RGL
     # Returns a new empty DirectedAdjacencyGraph which has as its edgelist
     # class the given class.  The default edgelist class is Set, to ensure
     # set semantics for edges and vertices.
-
-    def initialize (edgelist_class = Set)
+    #
+    # If other graphs are passed as parameters their vertices and edges are
+    # added to the new graph.
+    def initialize (edgelist_class = Set, *other_graphs)
       @edgelist_class = edgelist_class
       @vertice_dict   = Hash.new
+      other_graphs.each do |g|
+        g.each_vertex {|v| add_vertex v}
+        g.each_edge {|v,w| add_edge v,w}
+      end
+    end
+
+    # Copy internal vertice_dict
+    def initialize_copy(orig)
+      @vertice_dict = orig.instance_eval{@vertice_dict}.dup
+      @vertice_dict.keys.each do |v|
+        @vertice_dict[v] = @vertice_dict[v].dup
+      end
     end
 
     # Iterator for the keys of the vertice list hash.
@@ -48,8 +62,8 @@ module RGL
     end
 
     def each_adjacent (v, &b)			# :nodoc:
-      adjacency_list = @vertice_dict[v] or
-        raise NoVertexError, "No vertex #{v}."
+      adjacency_list = (@vertice_dict[v] or
+        raise NoVertexError, "No vertex #{v}.")
       adjacency_list.each(&b)
     end
 
@@ -109,6 +123,15 @@ module RGL
       @vertice_dict[u].delete(v) unless @vertice_dict[u].nil?
     end
 
+    # Converts the adjacency list of each vertex to be of type _klass_. The
+    # class is expected to have a new contructor which accepts an enumerable as
+    # parameter.
+    def edgelist_class=(klass)
+      @vertice_dict.keys.each do |v|
+         @vertice_dict[v] = klass.new @vertice_dict[v].to_a
+      end
+    end
+
     protected
 
     def basic_add_edge (u, v)
@@ -175,9 +198,7 @@ module RGL
 
     def to_undirected
       return self unless directed?
-      result = AdjacencyGraph.new
-      each_edge { |u,v| result.add_edge(u, v) }
-      result
+      AdjacencyGraph.new(Set, self)
     end
 
   end		# module Graph

data/lib/rgl/base.rb

@@ -3,52 +3,9 @@
 # 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.
+require 'rgl/enumerable_ext'
 
-RGL_VERSION = "0.2.3"
-
-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
+RGL_VERSION = "0.3.0"
 
 module RGL
   class NotDirectedError < RuntimeError; end
@@ -61,11 +18,11 @@ module RGL
   # 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
+    # Simply a directed pair (source -> target). Most 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). 
+    # explicitly DirecteEdge or UnDirectedEdge instances are returned
+    # (i.e. Graph#edges).
     class DirectedEdge
       attr_accessor :source, :target
 
@@ -122,47 +79,47 @@ module RGL
       # 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
-  # http://www.boost.org/libs/graph/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.
+  # In BGL terminology the module Graph defines the graph concept (see
+  # http://www.boost.org/libs/graph/doc/graph_concepts.html). We however do not
+  # distinguish between the IncidenceGraph, EdgeListGraph and VertexListGraph
+	# concepts, which would complicate the interface too 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().
+  # The RGL Graph concept contains only a few requirements that are common to
+	# all the graph concepts. These include, especially, the iterators defining
+	# the sets 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
+    # The each_vertex iterator defines the set of vertices. This method must be
+    # defined by concrete graph classes. It defines the BGL VertexListGraph
     # concept.
-    def each_vertex
+    def each_vertex () # :yields: v
       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
+    # method must be defined by concrete graph classes. Its defines the BGL
     # IncidenceGraph concept.
-    def each_adjacent (v)
+    def each_adjacent (v) # :yields: 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
+    # This method must _not_ be defined by 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
+    # undirected graph the function is inefficient because we must not yield
     # (v,u) if we already visited edge (u,v).
     def each_edge (&block)
       if directed?
@@ -173,26 +130,26 @@ module RGL
         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).
+    # 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 be 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.
+    # Returns true if the graph has no vertices, 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.
+    # 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.
@@ -214,8 +171,8 @@ module RGL
       r
     end
 
-    # Returns the number of out-edges (for directed graphs) or the number of incident
-    # edges (for undirected graphs) of vertex _v_.
+    # 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}
@@ -225,11 +182,8 @@ module RGL
     # Returns the number of vertices.
     def size()                  # Why not in Enumerable?
       inject(0) { |n, v| n + 1 }
-      #r = 0; each_vertex {|v| r +=1}; r
     end
-
-    # Synonym for size.
-    def num_vertices; size; end
+		alias :num_vertices :size
 
     # Returns the number of edges.
     def num_edges; r = 0; each_edge {|u,v| r +=1}; r; end
@@ -239,8 +193,23 @@ module RGL
       edges.sort.to_s
     end
 
+    # Equality is defined to be same set of edges and directed?
+    def eql?(g)
+      equal?(g) or
+        begin
+          g.is_a?(Graph) and directed? == g.directed? and
+            g.inject(0) { |n, v| has_vertex?(v) or return false; n+1} ==
+            num_vertices and begin
+                               ng = 0
+                               g.each_edge {|u,v| has_edge? u,v or return false; ng += 1}
+                               ng == num_edges
+                             end
+        end
+    end
+    alias == eql?
+
     private
-    
+
     def each_edge_aux
       # needed in each_edge
       visited = Hash.new
@@ -256,40 +225,5 @@ module RGL
     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; because 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