rgl 0.2.2 → 0.2.3

data/ChangeLog

@@ -1,3 +1,76 @@
+2005-03-30  monora  <monora@r40>
+
+        * tests/TestDirectedGraph.rb:
+        Added test for isolated vertices in DirectedGraph#reverse.
+
+        * lib/rgl/adjacency.rb:
+        Fixed bug in DirectedGraph#reverse reported by Kaspar Schiess. Isolated
+        vertices were not treated correctly.
+
+2005-03-26  wsdng  <wsdng@r40>
+
+        * lib/rgl/rdot.rb: added node and edge attributes
+
+2005-03-22  monora  <monora@r40>
+
+        * Rakefile: Fixed autorequire to work with gem version 0.8.8
+
+2005-02-04  monora  <monora@r40>
+
+        * README, lib/rgl/adjacency.rb, lib/rgl/base.rb, lib/rgl/connected_components.rb, lib/rgl/dot.rb, lib/rgl/graphxml.rb, lib/rgl/implicit.rb, lib/rgl/mutable.rb, lib/rgl/rdot.rb, lib/rgl/topsort.rb, lib/rgl/transitiv_closure.rb, lib/rgl/traversal.rb:
+        Fixed some formatting issues and smoothed documentation. Thanks to Rich Morin.
+
+2004-12-13  monora  <monora@r40>
+
+        * Makefile, README, Rakefile, lib/rgl/base.rb, lib/rgl/graphxml.rb, lib/rgl/implicit.rb, lib/rgl/traversal.rb:
+        Polished documentation
+
+        * lib/rgl/adjacency.rb, tests/TestDirectedGraph.rb, tests/TestUnDirectedGraph.rb:
+        Fixed bug in Graph#reverse reported by Sascha Ebach.
+
+2004-12-12  cyent  <cyent@r40>
+
+        * tests/TestGraphXML.rb: Fixed bug in relative path
+
+        * tests/TestDirectedGraph.rb: Added test_random
+
+        * lib/rgl/adjacency.rb, lib/rgl/base.rb, lib/rgl/connected_components.rb, lib/rgl/rdot.rb:
+        Fixed comments, removed warnings in ruby1.9 -w by adding attr_readers, told emacs to use tab-width 4 on these files
+
+2004-12-11  monora  <monora@r40>
+
+        * README, Rakefile, examples/examples.rb, lib/rgl/base.rb, lib/rgl/graphxml.rb, lib/rgl/traversal.rb, lib/stream.rb, tests/TestGraphXML.rb, tests/_TestGraphXML.rb:
+        Added gem packaging.
+
+2004-10-08  monora  <monora@r40>
+
+        * tests/runtests.rb: In new testframework not needed.
+
+        * lib/utils.rb: Code move to base.rb
+
+2004-10-06  monora  <monora@r40>
+
+        * lib/rgl/base.rb: Code from utils.rb included
+
+        * Rakefile: First start for gem preparation
+
+2003-07-30  monora  <monora@r40>
+
+        * lib/rgl/implicit.rb, lib/utils.rb, tests/TestComponents.rb, tests/TestDirectedGraph.rb, tests/TestImplicit.rb, tests/TestTransitiveClosure.rb, tests/TestTraversal.rb, tests/TestUnDirectedGraph.rb, tests/_TestGraphXML.rb, tests/runtests.rb:
+        - port to ruby 1.8
+        - compiler warnings removed
+        - set_up -> setup in testfiles
+
+2002-11-13  monora  <monora@r40>
+
+        * lib/rgl/dot.rb, lib/rgl/rdot.rb:
+        Name-attribute of DOTNode has to be escaped by ".
+
+2002-11-10  monora  <monora@r40>
+
+        * lib/set.rb, lib/rgl/adjacency.rb, lib/utils.rb:
+        Use knus compatibility library for Ruby 1.8 esp. for set.rb and inject.
+
 2002-11-10  monora  <monora@HDDESKTOP>
 
 	* lib/set.rb, lib/rgl/adjacency.rb, lib/utils.rb:
@@ -63,11 +136,11 @@
 	* adjacency.rb, base.rb, connected_components.rb, dot.rb, graphxml.rb, implicit.rb, mutable.rb, topsort.rb, transitiv_closure.rb:
 	started at sf
 
-2002-06-10  Horst Duchene  <horst@hduchene.de>
+2002-06-10  Horst Duchene  <horst>
 
 	* lib/rgl/graphxml.rb: added + tests + examples from graphviz catalog
 
-2002-03-21  Horst Duchene  <horst@hduchene.de>
+2002-03-21  Horst Duchene  <horst>
 
 	* Ported tests to Test::Unit
 	* transitive_closure.rb

data/README

@@ -39,13 +39,13 @@ genericity:
 * Vertex and Edge Property Multi-Parameterization
 
 The first is easily achieved in RGL using mixins, which of course is not as
-efficient than C++ templates (but much more readable :-). The second one is even
-more easily implemented using standard iterators with blocks or using the
-Stream module. The third one is no issue since Ruby is dynamically typed: Each
-object can be a graph vertex. There is no need for a vertex (or even edge
-type). In the current version of RGL properties of vertices are simply attached
-using hashes. At first there seems to be not much need for the graph property
-machinery.
+efficient than C++ templates (but much more readable :-). The second one is
+even more easily implemented using standard iterators with blocks or using the
+Stream[http://rgl.rubyforge.org/stream/files/README.html] module. The third one
+is no issue since Ruby is dynamically typed: Each object can be a graph
+vertex. There is no need for a vertex (or even edge type). In the current
+version of RGL properties of vertices are simply attached using hashes. At
+first there seems to be not much need for the graph property machinery.
 
 === Algorithms
 
@@ -87,22 +87,49 @@ http://www.boost.org/libs/graph/doc/graph_concepts.html
 
 == Installation
 
-RGL is depended on the _stream_ library which can also be downloaded from
-http://rubyforge.org/frs/?group_id=110.
+RGL is depended on the
+stream[http://rgl.rubyforge.org/stream/files/README.html] library which can
+also be downloaded from http://rubyforge.org/frs/?group_id=110. If you use gem
+to install RGL the stream library will be installed as a prerequisite.
 
 === GEM Installation
 
 Download the GEM file and install it with ..
 
-   gem install rgl-VERSION.gem
+  % gem install rgl-VERSION.gem
 
 or directly with 
 
-   gem install rgl
+  % gem install rgl
 
 Use the correct version number for VERSION (e.g. 0.2.2).  You may need root
 privileges to install.
 
+=== Running tests
+
+RGL comes with a Rakefile which automatically runs the tests. Goto the
+installation directory and start rake:
+
+ % gem env
+ Rubygems Environment:
+  - VERSION: 0.8.3 (0.8.3)
+  - 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
+ Started
+ ........................................................................................................
+ Finished in 0.736444 seconds.
+
+ 40 tests, 421 assertions, 0 failures, 0 errors
+
 === Normal Installation
 
 You have to install stream library before. You can than install RGL with the
@@ -130,8 +157,8 @@ The result: link:../examples/example.jpg
   irb> dg.has_vertex? 4
   true
 
-Every object could be a vertex (there is no class Vertex), even the class object
-_Object_:
+Every object could be a vertex (there is no class Vertex), even the class
+object _Object_:
 
   irb> dg.has_vertex? Object
   false
@@ -158,7 +185,7 @@ Add inverse edge (4-2) to directed graph:
 
 <em>Topological sort</em> is realized with as iterator:
 
-  require 'graph/traversal'
+  require 'graph/topsort'
   irb> dg.topsort_iterator.to_a
   [1, 2, 3, 6, 4, 5]
 
@@ -178,7 +205,7 @@ A more elaborated example showing <em>implicit graphs</em>:
 	}
   end
 
-This function creates a directed graph with vertices being all loaded modules:
+This function creates a directed graph, with vertices being all loaded modules:
 
   g = module_graph
 
@@ -186,8 +213,8 @@ We only want to see the ancestors of RGL::AdjacencyGraph:
 
   tree = bfs_search_tree_from(g,RGL::AdjacencyGraph)
 
-Now we want to visualize this component of g with DOT. We therefore create a
-subgraph of the original graph using a filtered graph:
+Now we want to visualize this component of g with DOT.  We therefore create a
+subgraph of the original graph, using a filtered graph:
 
   g = g.vertices_filtered_by {|v| tree.has_vertex? v}
 
@@ -208,26 +235,23 @@ graph resources. Manuel Simoni found a subtle bug in a preliminary version
 announced at http://rubygarden.com/ruby?RubyAlgorithmPackage/Graph.
 
 Robert kindly allowed to integrate his work on graphr, which I did not yet
-succeed. Especially his work to output graphs for GraphViz (see
-http://www.research.att.com/sw/tools/graphviz/download.html) is much more
-elaborated than the minimal support in dot.rb.
-
-Jason Voegele for set.rb implementing sets using hashes. These are used in the
-implementation of adjacency lists in AdjacencyGraph.
+succeed. Especially his work to output graphs for
+GraphViz[http://www.research.att.com/sw/tools/graphviz/download.html] is much
+more elaborated than the minimal support in dot.rb.
 
 Jeremy Siek one of the authors of the nice book "The Boost Graph Library (BGL)"
-(http://cseng.awl.com/book/0,3828,0201729148,00.html) kindly allowed to use the
+(http://www.boost.org/libs/graph/doc) kindly allowed to use the
 BGL documentation as a _cheap_ reference for RGL. He and Robert also gave
 feedback and many ideas for RGL.
 
-Dave Thomas for RDoc (http://rdoc.sourceforge.net) which generated what you read
+Dave Thomas for RDoc[http://rdoc.sourceforge.net] which generated what you read
 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).
+module dot/dot.rb which I use instead of Roberts module to visualize graphs
+(see rgl/dot.rb).
 
 == Copying
 
-RGL is Copyright (c) 2002,2004 by Horst Duchene.  It is free software, and may be
+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.
 

data/Rakefile

@@ -127,7 +127,7 @@ else
     #### Load-time details: library and application (you will need one or both).
 
     s.require_path = 'lib'                         # Use these for libraries.
-    s.autorequire = 'rgl'
+    s.autorequire = 'rgl/base'
 
     #### Documentation and testing.
 
@@ -141,7 +141,7 @@ else
     #### Author and project details.
     s.author = "Horst Duchene"
     s.email = "hd.at.clr@hduchene.de"
-    s.homepage = "rgl.rubyforge.org"
+    s.homepage = "http://rgl.rubyforge.org"
     s.rubyforge_project = "rgl"
   end
 
@@ -205,6 +205,6 @@ end
 
 desc "Copy rdoc html to rubyforge"
 task :rdoc2rf => [:rdoc] do
-  #sh "scp -r #{RDOC_DIR} monora@rubyforge.org:/var/www/gforge-projects/rgl"
+  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/TAGS

@@ -1,209 +1,253 @@
 
-lib/rgl/adjacency.rb,956
-module RGLRGL
16,586
-  class DirectedAdjacencyGraphDirectedAdjacencyGraph
17,597
-	def initialize(edgelist_class=Set)initialize
33,1091
-	def each_vertex(&b)each_vertex
39,1248
-	def each_adjacent(v, &b)	# :nodoc:each_adjacent
43,1305
-	def directed?; true; enddirected?
49,1470
-	def has_vertex?(v); @vertice_dict.has_key?(v); endhas_vertex?
53,1619
-	def has_edge? (u, v)has_edge?
60,1799
-	def add_vertex(v)add_vertex
67,1981
-	def add_edge (u,v)add_edge
72,2080
-	def remove_vertex(v)remove_vertex
79,2230
-	def remove_edge (u,v)remove_edge
87,2422
-	def basic_add_edge(u,v)basic_add_edge
93,2522
-  class AdjacencyGraph < DirectedAdjacencyGraphAdjacencyGraph
101,2812
-	def directed?; false; enddirected?
103,2885
-	def remove_edge (u,v)remove_edge
106,2936
-	def basic_add_edge(u,v)basic_add_edge
112,3044
-  module GraphGraph
119,3143
-	def to_adjacencyto_adjacency
122,3291
-	def reversereverse
132,3639
-	def to_undirectedto_undirected
144,4009
+lib/rgl/adjacency.rb,998
+module RGLRGL
18,633
+  class DirectedAdjacencyGraphDirectedAdjacencyGraph
20,645
+    def initialize (edgelist_class = Set)initialize
39,1191
+    def each_vertex (&b)each_vertex
46,1369
+    def each_adjacent (v, &b)			# :nodoc:each_adjacent
50,1436
+    def directed?directed?
58,1628
+    def has_vertex? (v)has_vertex?
65,1799
+    def has_edge? (u, v)has_edge?
75,2023
+    def add_vertex (v)add_vertex
84,2242
+    def add_edge (u, v)add_edge
90,2355
+    def remove_vertex (v)remove_vertex
98,2568
+    def remove_edge (u, v)remove_edge
108,2788
+    def basic_add_edge (u, v)basic_add_edge
114,2901
+  class AdjacencyGraph < DirectedAdjacencyGraph AdjacencyGraph
124,3211
+    def directed?				# Always returns false.directed?
126,3261
+    def remove_edge (u, v)remove_edge
132,3361
+    def basic_add_edge (u,v)basic_add_edge
139,3486
+  module GraphGraph
146,3623
+    def to_adjacencyto_adjacency
151,3797
+    def reversereverse
162,4177
+    def to_undirectedto_undirected
176,4637
 
-lib/rgl/base.rb,1907
-  module EnumerableEnumerable
12,301
-	def inject(*argv)inject
13,321
-module EnumerableEnumerable
41,700
-  def lengthlength
48,892
-module RGLRGL
55,954
-  class NotDirectedError < RuntimeError; endNotDirectedError
56,965
-  class NotUndirectedError < RuntimeError; endNotUndirectedError
57,1010
-  class NoVertexError < IndexError; endNoVertexError
59,1058
-  class NoEdgeError < IndexError; endNoEdgeError
60,1098
-  module EdgeEdge
65,1327
-	class DirectedEdgeDirectedEdge
71,1651
-	  def initialize (a,b)initialize
80,1874
-	  def eql?(edge)eql?
86,2086
-	  def reversereverse
92,2216
-	  def to_sto_s
101,2504
-	  def to_a; [source,target]; endto_a
105,2589
-	class UnDirectedEdge < DirectedEdgeUnDirectedEdge
115,2894
-	  def eql?(edge)eql?
116,2931
-	  def hashhash
120,3021
-	  def to_s; "(#{source}=#{target})"; endto_s
125,3113
-  module GraphGraph
144,3938
-	def each_vertexeach_vertex
151,4151
-	def each_adjacent (v)each_adjacent
159,4401
-	def each_edge (&block)each_edge
171,4882
-	def each(&block); each_vertex(&block); endeach
184,5165
-	def directed?; false; enddirected?
187,5264
-	def has_vertex?(v); include?(v); end	# inherited from enumerablehas_vertex?
192,5490
-	def empty?; num_vertices.zero?; endempty?
197,5668
-	def vertices; to_a; endvertices
200,5781
-	def edge_class; directed? ? DirectedEdge : UnDirectedEdge; endedge_class
203,5871
-	def edgesedges
207,6079
-	def adjacent_vertices (v)adjacent_vertices
215,6239
-	def out_degree (v)out_degree
223,6451
-	def size # Why not in Enumerable?size
230,6560
-	def num_vertices; size; endnum_vertices
236,6732
-	def num_edges; r = 0; each_edge {|u,v| r +=1}; r; endnum_edges
239,6794
-	def to_sto_s
242,6927
-	def each_edge_auxeach_edge_aux
248,6973
-  module BidirectionalGraphBidirectionalGraph
272,7816
-	def each_in_neighbor (v)each_in_neighbor
279,8156
-	def in_degree (v)in_degree
286,8359
-	def degree (v)degree
294,8582
+lib/rgl/base.rb,2023
+  module EnumerableEnumerable
10,277
+    def inject(*argv)inject
11,297
+module EnumerableEnumerable
39,787
+  def lengthlength
46,979
+module RGLRGL
53,1050
+  class NotDirectedError < RuntimeError; endNotDirectedError
54,1061
+  class NotUndirectedError < RuntimeError; endNotUndirectedError
55,1106
+  class NoVertexError < IndexError; endNoVertexError
57,1154
+  class NoEdgeError < IndexError; endNoEdgeError
58,1194
+  module EdgeEdge
63,1423
+    class DirectedEdgeDirectedEdge
69,1762
+      def initialize (a,b)initialize
78,2009
+      def eql?(edge)eql?
84,2242
+      def reversereverse
90,2390
+      def to_sto_s
99,2702
+      def to_a; [source,target]; endto_a
103,2802
+    class UnDirectedEdge < DirectedEdgeUnDirectedEdge
113,3152
+      def eql?(edge)eql?
114,3192
+      def hashhash
118,3297
+      def to_s; "(#{source}=#{target})"; endto_s
123,3407
+  module GraphGraph
140,4274
+    def each_vertexeach_vertex
147,4502
+    def each_adjacent (v)each_adjacent
155,4787
+    def each_edge (&block)each_edge
167,5315
+    def each(&block); each_vertex(&block); endeach
180,5654
+    def directed?; false; enddirected?
183,5762
+    def has_vertex?(v); include?(v); end    # inherited from enumerablehas_vertex?
188,6000
+    def empty?; num_vertices.zero?; endempty?
193,6193
+    def vertices; to_a; endvertices
196,6312
+    def edge_class; directed? ? DirectedEdge : UnDirectedEdge; endedge_class
199,6408
+    def edgesedges
203,6625
+    def adjacent_vertices (v)adjacent_vertices
211,6806
+    def out_degree (v)out_degree
219,7039
+    def size()                  # Why not in Enumerable?size
226,7166
+    def num_vertices; size; endnum_vertices
232,7330
+    def num_edges; r = 0; each_edge {|u,v| r +=1}; r; endnum_edges
235,7398
+    def to_sto_s
238,7537
+    def each_edge_auxeach_edge_aux
244,7598
+  module BidirectionalGraphBidirectionalGraph
268,8533
+    def each_in_neighbor (v)each_in_neighbor
275,8888
+    def in_degree (v)in_degree
282,9112
+    def degree (v)degree
290,9356
 
-lib/rgl/connected_components.rb,497
-module RGLRGL
7,233
-  module GraphGraph
8,244
-	def each_connected_componenteach_connected_component
17,641
-	class TarjanSccVisitor < DFSVisitorTarjanSccVisitor
34,1174
-	  def initialize(g)initialize
38,1314
-	  def handle_examine_vertex(v)handle_examine_vertex
48,1458
-	  def handle_finish_vertex(v)handle_finish_vertex
56,1606
-	  def num_compnum_comp
75,2151
-	  def min_discover_time(u,v)min_discover_time
81,2198
-	def strongly_connected_componentsstrongly_connected_components
118,3687
+lib/rgl/connected_components.rb,527
+module RGLRGL
9,261
+  module GraphGraph
11,273
+    def each_connected_componenteach_connected_component
23,720
+    class TarjanSccVisitor < DFSVisitorTarjanSccVisitor
41,1322
+      def initialize (g)initialize
47,1473
+      def handle_examine_vertex (v)handle_examine_vertex
57,1721
+      def handle_finish_vertex (v)handle_finish_vertex
65,1912
+      def num_compnum_comp
85,2561
+      def min_discover_time (u, v)min_discover_time
91,2623
+    def strongly_connected_componentsstrongly_connected_components
129,4218
 
-lib/rgl/dot.rb,298
-module RGLRGL
10,239
-  module GraphGraph
11,250
-	def to_dot_graph( params = {} )to_dot_graph
15,428
-	def print_dotted_on (params = {}, s=$stdout)print_dotted_on
35,1076
-	def dotty( params = {} )dotty
41,1270
-	def write_to_graphic_file(fmt='png', dotfile="graph")write_to_graphic_file
51,1530
+lib/rgl/dot.rb,309
+module RGLRGL
11,251
+  module GraphGraph
13,263
+  def to_dot_graph (params = {})to_dot_graph
19,447
+    def print_dotted_on (params = {}, s = $stdout)print_dotted_on
40,1239
+    def dotty (params = {})dotty
47,1453
+    def write_to_graphic_file (fmt='png', dotfile="graph")write_to_graphic_file
58,1744
 
-lib/rgl/graphxml.rb,340
-module RGLRGL
15,594
-  module GraphXMLGraphXML
22,893
-	class MutableGraphParserMutableGraphParser
23,911
-	  def initialize(graph)initialize
26,992
-	  def tag_start(name, attrs)tag_start
30,1042
-	def MutableGraph.append_features(includingClass)append_features
41,1229
-	  def includingClass.from_graphxml (source)from_graphxml
45,1350
+lib/rgl/graphxml.rb,359
+module RGLRGL
18,614
+  module GraphXMLGraphXML
27,905
+    class MutableGraphParserMutableGraphParser
29,924
+      def initialize (graph)initialize
35,1017
+      def tag_start (name, attrs)tag_start
39,1080
+    def MutableGraph.append_features (includingClass)append_features
50,1341
+      def includingClass.from_graphxml (source)from_graphxml
55,1473
 
-lib/rgl/implicit.rb,681
-module RGLRGL
19,702
-  class ImplicitGraphImplicitGraph
20,713
-	def initializeinitialize
32,1102
-	def directed?; @directed; enddirected?
40,1337
-	def each_vertex (&block)	# :nodoc:each_vertex
42,1370
-	def each_adjacent (v, &block) # :nodoc:each_adjacent
46,1444
-	def each_edge (&block) # :nodoc:each_edge
50,1527
-	def vertex_iterator (&block)vertex_iterator
60,1811
-	def adjacent_iterator (&block)adjacent_iterator
69,2127
-	def edge_iterator (&block)edge_iterator
76,2367
-  module GraphGraph
81,2433
-	def vertices_filtered_by (&filter)vertices_filtered_by
105,3129
-	def edges_filtered_by (&filter)edges_filtered_by
124,3675
-	def implicit_graphimplicit_graph
141,4120
+lib/rgl/implicit.rb,704
+module RGLRGL
23,730
+  class ImplicitGraphImplicitGraph
25,742
+    def initializeinitialize
39,1182
+    def directed?directed?
48,1440
+    def each_vertex (&block)			# :nodoc:each_vertex
52,1491
+    def each_adjacent (v, &block)		# :nodoc:each_adjacent
56,1576
+    def each_edge (&block)			# :nodoc:each_edge
60,1670
+    def vertex_iterator (&block)vertex_iterator
72,1997
+    def adjacent_iterator (&block)adjacent_iterator
85,2365
+    def edge_iterator (&block)edge_iterator
93,2623
+  module GraphGraph
100,2723
+    def vertices_filtered_by (&filter)vertices_filtered_by
126,3533
+    def edges_filtered_by (&filter)edges_filtered_by
146,4175
+    def implicit_graphimplicit_graph
163,4698
 
-lib/rgl/mutable.rb,484
-module RGLRGL
3,20
-  module MutableGraphMutableGraph
6,121
-	def add_vertex(v); raise NotImplementedError; endadd_vertex
11,266
-	def add_edge(u, v); raise NotImplementedError; endadd_edge
20,692
-	def add_vertices (*a)add_vertices
23,790
-	def add_edges (*edges)add_edges
30,1010
-	def remove_vertex(v); raise NotImplementedError; endremove_vertex
39,1365
-	def remove_edge(u, v); raise NotImplementedError; endremove_edge
46,1653
-	def remove_vertices (*a)remove_vertices
50,1798
+lib/rgl/mutable.rb,382
+module RGLRGL
5,34
+  module MutableGraphMutableGraph
10,137
+    def add_vertex (v)add_vertex
17,310
+    def add_edge (u, v)add_edge
29,770
+    def add_vertices (*a)add_vertices
35,884
+    def add_edges (*edges)add_edges
43,1127
+    def remove_vertex (v)remove_vertex
53,1512
+    def remove_edge (u, v)remove_edge
63,1831
+    def remove_vertices (*a)remove_vertices
70,1998
 
-lib/rgl/rdot.rb,1615
-module DOTDOT
9,242
-    def change_tab( t )change_tab
16,420
-    class DOTSimpleElementDOTSimpleElement
81,1613
-        def initialize( params = {} )initialize
84,1669
-        def to_sto_s
88,1778
-    class DOTElement < DOTSimpleElementDOTElement
94,1897
-        def initialize( params = {}, option_list = [] )initialize
98,2005
-        def each_optioneach_option
109,2419
-        def each_option_paireach_option_pair
113,2497
-    class DOTPort < DOTSimpleElementDOTPort
126,2856
-        def initialize( params = {} )initialize
129,2931
-        def to_sto_s
133,3068
-    class DOTNode < DOTElementDOTNode
139,3200
-        def initialize( params = {}, option_list = NODE_OPTS )initialize
142,3247
-        def each_porteach_port
147,3424
-        def push ( thing )push
155,3564
-        def poppop
159,3637
-        def to_s( t = '' )to_s
163,3689
-    class DOTSubgraph < DOTElementDOTSubgraph
188,4604
-        def initialize( params = {}, option_list = GRAPH_OPTS )initialize
192,4675
-        def each_nodeeach_node
198,4887
-        def push( thing )push
206,5034
-        def poppop
210,5106
-        def to_s( t = '' )to_s
214,5158
-    class DOTDigraph < DOTSubgraphDOTDigraph
231,5663
-        def initialize( params = {}, option_list = GRAPH_OPTS )initialize
232,5698
-    class DOTEdge < DOTElementDOTEdge
239,5879
-        def initialize( params = {}, option_list = EDGE_OPTS )initialize
241,5943
-		def edge_link; '--'; endedge_link
247,6177
-        def to_s( t = '' )to_s
248,6204
-	class DOTDirectedEdge < DOTEdgeDOTDirectedEdge
258,6557
-	  def edge_link; '->'; endedge_link
259,6590
+lib/rgl/rdot.rb,1493
+module DOTDOT
10,254
+  def change_tab (t)change_tab
19,428
+  class DOTSimpleElementDOTSimpleElement
118,4745
+    def initialize (params = {})initialize
122,4796
+    def to_sto_s
126,4890
+  class DOTElement < DOTSimpleElementDOTElement
133,4992
+    def initialize (params = {}, option_list = [])initialize
138,5092
+    def each_optioneach_option
149,5451
+    def each_option_paireach_option_pair
153,5515
+  class DOTPort < DOTSimpleElementDOTPort
168,5840
+    def initialize (params = {})initialize
172,5910
+    def to_sto_s
177,6025
+  class DOTNode < DOTElementDOTNode
184,6140
+    def initialize (params = {}, option_list = NODE_OPTS)initialize
188,6182
+    def each_porteach_port
193,6336
+    def push (thing)push
201,6447
+    def poppop
205,6502
+    def to_s (t = '')to_s
209,6540
+  class DOTSubgraph < DOTElementDOTSubgraph
238,7531
+    def initialize (params = {}, option_list = GRAPH_OPTS)initialize
243,7593
+    def each_nodeeach_node
249,7781
+    def push (thing)push
257,7898
+    def poppop
261,7955
+    def to_s (t = '')to_s
265,7993
+  class DOTDigraph < DOTSubgraphDOTDigraph
284,8473
+    def initialize (params = {}, option_list = GRAPH_OPTS)initialize
286,8507
+  class DOTEdge < DOTElementDOTEdge
295,8687
+    def initialize (params = {}, option_list = EDGE_OPTS)initialize
299,8747
+    def edge_linkedge_link
305,8954
+    def to_s (t = '')to_s
309,8992
+  class DOTDirectedEdge < DOTEdgeDOTDirectedEdge
320,9341
+    def edge_linkedge_link
322,9376
 
-lib/rgl/topsort.rb,447
-module RGLRGL
3,25
-  class TopsortIteratorTopsortIterator
14,503
-	def initialize(g)initialize
16,550
-	def set_to_begin					# :nodoc:set_to_begin
21,602
-	def basic_forward					# :nodoc:basic_forward
36,924
-	def at_beginning?; true; end		# :nodoc: FIXMEat_beginning?
45,1091
-	def at_end?; @waiting.empty?; end	# :nodoc:at_end?
46,1138
-  module GraphGraph
49,1190
-	def topsort_iteratortopsort_iterator
51,1235
-	def acyclic?acyclic?
57,1425
+lib/rgl/topsort.rb,484
+module RGLRGL
5,39
+  class TopsortIteratorTopsortIterator
17,521
+    def initialize (g)initialize
21,573
+    def set_to_begin				# :nodoc:set_to_begin
26,639
+    def basic_forward				# :nodoc:basic_forward
42,1017
+    def at_beginning?; true;            end	# :nodoc: FIXMEat_beginning?
51,1213
+    def at_end?;       @waiting.empty?; end	# :nodoc:at_end?
52,1273
+  module GraphGraph
56,1360
+    def topsort_iteratortopsort_iterator
60,1410
+    def acyclic?acyclic?
67,1627
 
-lib/rgl/transitiv_closure.rb,127
-module RGLRGL
9,334
-  module GraphGraph
10,345
-	def transitive_closure_floyd_warshaltransitive_closure_floyd_warshal
16,665
+lib/rgl/transitiv_closure.rb,131
+module RGLRGL
12,362
+  module GraphGraph
14,374
+    def transitive_closure_floyd_warshaltransitive_closure_floyd_warshal
23,721
 
-lib/rgl/traversal.rb,1708
-module RGLRGL
14,546
-  module GraphWrapper					# :nodoc:GraphWrapper
15,557
-	def initialize(graph); @graph = graph; endinitialize
19,658
-  module GraphIteratorGraphIterator
24,863
-  module GraphVisitorGraphVisitor
59,2225
-	def initialize(graph)initialize
64,2335
-	def resetreset
70,2432
-	def finished_vertex? vfinished_vertex?
75,2546
-	def attach_distance_map(map=Hash.new(0))attach_distance_map
87,2937
-		def handle_tree_edge(u,v)handle_tree_edge
90,3015
-		def distance_to_root(v)distance_to_root
96,3141
-	def follow_edge?(u,v)		# :nodoc:follow_edge?
103,3261
-	def self.def_event_handler(m)def_event_handler
108,3355
-		def handle_#{m}(#{params})handle_
111,3446
-		def set_#{m}_event_handler(&b)set_
114,3553
-  class BFSIteratorBFSIterator
137,4373
-	def initialize(graph, start=graph.detect{|x| true})initialize
143,4535
-	def at_beginning?; @color_map.size == 1; end # :nodoc:at_beginning?
150,4727
-	def at_end?; @waiting.empty?; endat_end?
153,4823
-	def set_to_beginset_to_begin
156,4932
-	def basic_forward					# :nodoc:basic_forward
162,5098
-	def next_vertex	()					# :nodoc:next_vertex
186,5696
-  module GraphGraph
192,5804
-	def bfs_iterator (v=self.detect {|x| true})bfs_iterator
194,5867
-	def bfs_search_tree_from(v)bfs_search_tree_from
201,6151
-  class DFSIterator < BFSIteratorDFSIterator
218,6699
-	def next_vertexnext_vertex
219,6733
-  class DFSVisitorDFSVisitor
235,7372
-  module GraphGraph
241,7469
-	def dfs_iterator (v=self.detect {|x| true})dfs_iterator
243,7532
-	def depth_first_search (vis = DFSVisitor.new(self),&b)depth_first_search
250,7787
-	def depth_first_visit (u, vis = DFSVisitor.new(self), &b)depth_first_visit
261,8079
-  def acyclic?acyclic?
285,8775
+lib/rgl/traversal.rb,1779
+module RGLRGL
16,593
+  module GraphWrapper                                   # :nodoc:GraphWrapper
18,605
+    def initialize (graph)initialize
23,743
+  module GraphIteratorGraphIterator
31,1009
+  module GraphVisitorGraphVisitor
66,2413
+    def initialize (graph)initialize
74,2535
+    def resetreset
81,2649
+    def finished_vertex? (v)finished_vertex?
87,2777
+    def attach_distance_map (map = Hash.new(0))attach_distance_map
100,3220
+        def handle_tree_edge (u, v)handle_tree_edge
105,3312
+        def distance_to_root (v)distance_to_root
112,3471
+    def follow_edge? (u, v)			# :nodoc:follow_edge?
121,3630
+    def self.def_event_handler (m)def_event_handler
127,3740
+        def handle_#{m} (#{params})handle_
130,3841
+        def set_#{m}_event_handler (&b)set_
134,3968
+  class BFSIteratorBFSIterator
160,4865
+    def initialize (graph, start=graph.detect{ |x| true })initialize
169,5043
+    def at_beginning?				# :nodoc:at_beginning?
177,5258
+    def at_end?at_end?
183,5379
+    def set_to_beginset_to_begin
189,5503
+    def basic_forward				# :nodoc:basic_forward
195,5685
+    def next_vertex				# :nodoc:next_vertex
219,6414
+  module GraphGraph
226,6532
+    def bfs_iterator (v = self.detect { |x| true})bfs_iterator
230,6602
+    def bfs_search_tree_from (v)bfs_search_tree_from
238,6910
+  class DFSIterator < BFSIteratorDFSIterator
258,7523
+    def next_vertexnext_vertex
260,7558
+  class DFSVisitorDFSVisitor
279,8231
+  module GraphGraph
288,8357
+    def dfs_iterator (v = self.detect { |x| true })dfs_iterator
292,8425
+    def depth_first_search (vis = DFSVisitor.new(self), &b)depth_first_search
300,8706
+    def depth_first_visit (u, vis = DFSVisitor.new(self), &b)depth_first_visit
312,9047
+  def acyclic?acyclic?
337,9940
+
+lib/rgl/xx.rb,1766
+  module EnumerableEnumerable
15,316
+    def inject (*argv)inject
17,337
+module EnumerableEnumerable
47,910
+  def lengthlength
56,1106
+module RGLRGL
65,1200
+  class NotDirectedError   < RuntimeError;  end NotDirectedError
67,1212
+  class NotUndirectedError < RuntimeError;  end NotUndirectedError
68,1261
+  class NoVertexError      < IndexError;    end NoVertexError
69,1310
+  class NoEdgeError        < IndexError;    endNoEdgeError
70,1359
+  module EdgeEdge
76,1600
+    class DirectedEdgeDirectedEdge
84,1940
+      def initialize (a, b)initialize
96,2192
+      def eql? (edge)eql?
104,2441
+      def reversereverse
112,2592
+      def to_sto_s
125,2921
+      def to_ato_a
131,3024
+    class UnDirectedEdge < DirectedEdgeUnDirectedEdge
146,3378
+      def eql? (edge)eql?
148,3419
+      def hashhash
152,3529
+      def to_sto_s
158,3644
+  module GraphGraph
181,4544
+    def each_vertexeach_vertex
190,4775
+    def each_adjacent (v)each_adjacent
199,5049
+    def each_edge (&block)each_edge
212,5565
+    def each (&block)each
226,5916
+    def directed?directed?
232,6039
+    def has_vertex? (v)has_vertex?
240,6291
+    def empty?empty?
248,6495
+    def verticesvertices
254,6625
+    def edge_classedge_class
260,6730
+    def edgesedges
267,6956
+    def adjacent_vertices (v)adjacent_vertices
276,7143
+    def out_degree (v)out_degree
285,7379
+    def size		# Why not in Enumerable?size
293,7508
+    def num_verticesnum_vertices
303,7716
+    def num_edgesnum_edges
309,7793
+    def to_sto_s
317,7954
+    def each_edge_auxeach_edge_aux
323,8019
+  module BidirectionalGraphBidirectionalGraph
349,8937
+    def each_in_neighbor (v)each_in_neighbor
359,9301
+    def in_degree (v)in_degree
367,9530
+    def degree (v)degree
376,9775