rgl 0.5.9 → 0.5.10

data/examples/north/g.12.8.graphml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!-- This file was written by the internal XML-Handler of Y-Files.-->
-<!DOCTYPE graphml SYSTEM "http://www.graphdrawing.org/dtds/graphml.dtd">
+<!DOCTYPE graphml SYSTEM "https://www.graphdrawing.org/dtds/graphml.dtd">
 <graphml>
 <graph id="G">
 <node id="n0"/>

data/examples/north/g.14.9.graphml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!-- This file was written by the internal XML-Handler of Y-Files.-->
-<!DOCTYPE graphml SYSTEM "http://www.graphdrawing.org/dtds/graphml.dtd">
+<!DOCTYPE graphml SYSTEM "https://www.graphdrawing.org/dtds/graphml.dtd">
 <graphml>
 <graph id="G">
 <node id="n0"/>

data/examples/north.rb

@@ -6,7 +6,7 @@ include RGL
 
 Dir['north/*.graphml'].each do |filename|
   File.open(filename) { |file|
-    graph = DirectedAdjacencyGraph.from_graphxml(file)
+    graph = DirectedAdjacencyGraph.new.from_graphxml(file)
     graph.write_to_graphic_file('jpg', filename)
   }
 end

data/examples/rdep-rgl.rb

@@ -1,14 +1,14 @@
 #
 # Simple extensions of Hal Fultons tool to show dependencies between ruby
-# source files (see http://hypermetrics.com/rubyhacker/code/rdep/). The basic
+# source files (see https://hypermetrics.com/rubyhacker/code/rdep/). The basic
 # extensions can be found at the end of the function find_files.
 #
-# Source: [http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/rgl/rgl/examples/rdep-rgl.rb]
+# Source: [https://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/rgl/rgl/examples/rdep-rgl.rb]
 #
 # Additionaly rdep-rgl.rb generates a graphics file named
 # File.basename(ARGV[0]) + ".png".
 #
-# Requires RGL (http://rgl.sourceforge.net) and Graphviz
+# Requires RGL (https://rgl.sourceforge.net) and Graphviz
 # (www.research.att.com/sw/tools/graphviz/download.html).
 #
 #  ruby rdep-rgl.rb j:/ruby/lib/ruby/site_ruby/1.6/rdoc/rdoc.rb

data/lib/rgl/adjacency.rb

@@ -1,30 +1,27 @@
 # adjacency.rb
 #
-# $Id$
-#
-# The DirectedAdjacencyGraph class implements a generalized adjacency list
-# graph structure. An AdjacencyGraph is basically a two-dimensional structure
-# (ie, a list of lists). Each element of the first dimension represents a
-# vertex. 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. This can be configured by the client, however, when an AdjacencyGraph
-# is created.
-
 require 'rgl/mutable'
 require 'set'
 
 module RGL
 
+  # The +DirectedAdjacencyGraph+ class implements a generalized adjacency list
+  # graph structure. An AdjacencyGraph is basically a two-dimensional structure
+  # (ie, a list of lists). Each element of the first dimension represents a
+  # vertex. 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+. This can be configured by the client, however, when an AdjacencyGraph
+  # is created.
   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)"
+    # Shortcut for creating a DirectedAdjacencyGraph
+    # @example
+    #   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
@@ -32,13 +29,13 @@ module RGL
       result
     end
 
-    # 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.
+    # The new empty graph has as its edgelist class the given class. The default
+    # edgelist class is Set, to ensure set semantics for edges and vertices.
     #
     # If other graphs are passed as parameters their vertices and edges are
     # added to the new graph.
-    #
+    # @param [Class] edgelist_class
+    # @param [Array[Graph]] other_graphs
     def initialize(edgelist_class = Set, *other_graphs)
       @edgelist_class = edgelist_class
       @vertices_dict = Hash.new
@@ -58,58 +55,53 @@ module RGL
     end
 
     # Iterator for the keys of the vertices list hash.
-    #
+    # @see Graph#each_vertex
     def each_vertex(&b)
       @vertices_dict.each_key(&b)
     end
 
-    def each_adjacent(v, &b) # :nodoc:
+    # @see Graph#each_adjacent
+    def each_adjacent(v, &b)
       adjacency_list = (@vertices_dict[v] or raise NoVertexError, "No vertex #{v}.")
       adjacency_list.each(&b)
     end
 
-    # Returns true.
+    # @return true.
     #
     def directed?
       true
     end
 
-    # Complexity is O(1), because the vertices are kept in a Hash containing
+    # Complexity is O(1), because the vertices are kept in a +Hash+ containing
     # as values the lists of adjacent vertices of _v_.
     #
+    # @see Graph#has_vertex
     def has_vertex?(v)
       @vertices_dict.has_key?(v)
     end
 
     # Complexity is O(1), if a Set is used as adjacency list. Otherwise,
     # complexity is O(out_degree(v)).
-    #
-    # ---
-    # MutableGraph interface.
-    #
+    # @see Graph#has_edge?
     def has_edge?(u, v)
       has_vertex?(u) && @vertices_dict[u].include?(v)
     end
 
-    # See MutableGraph#add_vertex.
-    #
-    # If the vertex is already in the graph (using eql?), the method does
+    # If the vertex is already in the graph (using +eql?+), the method does
     # nothing.
-    #
+    # @see MutableGraph#add_vertex
     def add_vertex(v)
       @vertices_dict[v] ||= @edgelist_class.new
     end
 
-    # See MutableGraph#add_edge.
-    #
+    # @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.
-    #
+    # @see MutableGraph#remove_vertex.
     def remove_vertex(v)
       @vertices_dict.delete(v)
 
@@ -117,16 +109,15 @@ module RGL
       @vertices_dict.each_value { |adjList| adjList.delete(v) }
     end
 
-    # See MutableGraph::remove_edge.
-    #
+    # @see MutableGraph::remove_edge.
     def remove_edge(u, v)
       @vertices_dict[u].delete(v) unless @vertices_dict[u].nil?
     end
 
-    # Converts the adjacency list of each vertex to be of type _klass_. The
+    # Converts the adjacency list of each vertex to be of type +klass+. The
     # class is expected to have a new constructor which accepts an enumerable as
     # parameter.
-    #
+    # @param [Class] klass
     def edgelist_class=(klass)
       @vertices_dict.keys.each do |v|
         @vertices_dict[v] = klass.new @vertices_dict[v].to_a
@@ -141,20 +132,21 @@ module RGL
 
   end # class DirectedAdjacencyGraph
 
-  # 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.
+  # AdjacencyGraph is an undirected Graph. The methods
+  # {DirectedAdjacencyGraph#add_edge} and {DirectedAdjacencyGraph#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.
+    # @return false.
     #
     def directed?
       false
     end
 
     # Also removes (v,u)
-    #
+    # @see DirectedAdjacencyGraph#remove_edge
     def remove_edge(u, v)
       super
       @vertices_dict[v].delete(u) unless @vertices_dict[v].nil?
@@ -172,8 +164,8 @@ module RGL
   module Graph
 
     # Convert a general graph to an AdjacencyGraph. If the graph is directed,
-    # returns a DirectedAdjacencyGraph; otherwise, returns an AdjacencyGraph.
-    #
+    # returns a {DirectedAdjacencyGraph}; otherwise, returns an {AdjacencyGraph}.
+    # @return {DirectedAdjacencyGraph} or {AdjacencyGraph}
     def to_adjacency
       result = (directed? ? DirectedAdjacencyGraph : AdjacencyGraph).new
       each_vertex { |v| result.add_vertex(v) }
@@ -185,7 +177,7 @@ module RGL
     # 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.
-    #
+    # @return [DirectedAdjacencyGraph]
     def reverse
       return self unless directed?
       result = DirectedAdjacencyGraph.new
@@ -194,12 +186,12 @@ module RGL
       result
     end
 
-    # Return a new AdjacencyGraph which has the same set of vertices. If (u,v)
+    # Return a new {AdjacencyGraph} which has the same set of vertices. If (u,v)
     # is an edge of the graph, then (u,v) and (v,u) (which are the same edges)
     # are edges of the result.
     #
-    # If the graph is undirected, the result is self.
-    #
+    # If the graph is undirected, the result is +self+.
+    # @return [AdjacencyGraph]
     def to_undirected
       return self unless directed?
       AdjacencyGraph.new(Set, self)

data/lib/rgl/base.rb

@@ -1,10 +1,16 @@
 # base.rb
-#
-# 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.5.9"
+# version information
+RGL_VERSION = "0.5.10"
+
+# Module {RGL} defines the namespace for all modules and classes of the graph
+# library. The main module is {Graph} which defines the abstract behavior of
+# all graphs in the library. Other important modules or classes are:
+#
+# * Class {AdjacencyGraph} provides a concrete implementation of an undirected graph.
+# * Module {Edge} defines edges of a graph.
+# * {GraphIterator} and {GraphVisitor} provide support for iterating and searching.
+# * {DOT} helps to visualize graphs.
 
 module RGL
   class NotDirectedError < RuntimeError; end
@@ -17,16 +23,16 @@ module RGL
 
   INFINITY = 1.0 / 0.0 # positive infinity
 
-  # Module Edge includes classes for representing edges of directed and
-  # undirected graphs. There is no need for a Vertex class, because every ruby
+  # Module {Edge} includes classes for representing edges 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). 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 DirectedEdge or UnDirectedEdge instances are returned
-    # (i.e. Graph#edges).
+    # An {Edge} is 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 {Graph#each_edge}). If a client wants to
+    # store edges explicitly {DirectedEdge} or {UnDirectedEdge} instances are
+    # returned (i.e. {Graph#edges}).
     #
     class DirectedEdge
 
@@ -37,15 +43,14 @@ module RGL
         new(a[0], a[1])
       end
 
-      # Create a new DirectedEdge with source _a_ and target _b_.
+      # 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 ==.
-      #
+      # 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) && (target == edge.target)
       end
@@ -57,20 +62,22 @@ module RGL
       end
 
       # Returns (v,u) if self == (u,v).
-      #
+      # @return [Edge]
       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.
+      # Edges can be indexed. +edge.at(0) == edge.source+, +edge.at(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)"
-      #
+      # Returns string representation of the edge
+      # @example
+      #   DirectedEdge[1,2].to_s == "(1-2)"
+      # @return [String]
       def to_s
         "(#{source}-#{target})"
       end
@@ -79,7 +86,7 @@ module RGL
       alias inspect to_s
 
       # Returns the array [source,target].
-      #
+      # @return [Array]
       def to_a
         [source, target]
       end
@@ -93,15 +100,18 @@ module RGL
     end # DirectedEdge
 
     # An undirected edge is simply an undirected pair (source, target) used in
-    # undirected graphs. UnDirectedEdge[u,v] == UnDirectedEdge[v,u]
+    # undirected graphs.
+    # @example
+    #   UnDirectedEdge[u,v] == UnDirectedEdge[v,u]
     #
     class UnDirectedEdge < DirectedEdge
       def eql?(edge)
         super || ((target == edge.source) && (source == edge.target))
       end
 
-      # UnDirectedEdge[1,2].to_s == "(1=2)"
-      #
+      # @example
+      #   UnDirectedEdge[1,2].to_s == "(1=2)"
+      # @return (see DirectedEdge#to_s)
       def to_s
         "(#{source}=#{target})"
       end
@@ -110,18 +120,18 @@ module RGL
 
   end # Edge
 
-  # 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.
+  # In _BGL_ terminology the module Graph defines the graph concept (see {Graph
+  # Concepts}[https://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 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
+  # 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_edge}, {#num_vertices} or {#num_edges}.
   #
   # Each graph is an enumerable of vertices.
   #
@@ -129,30 +139,30 @@ module RGL
 
     include Enumerable
     include Edge
-    # The each_vertex iterator defines the set of vertices. This method must be
-    # defined by concrete graph classes. It defines the BGL VertexListGraph
-    # concept.
+    # The +each_vertex+ iterator defines the set of vertices of the graph. This
+    # method must be defined by concrete graph classes. It defines the BGL
+    # VertexListGraph concept.
     #
     def each_vertex() # :yields: v
       raise NotImplementedError
     end
 
-    # The each_adjacent iterator defines the out edges of vertex _v_. This
+    # The +each_adjacent+ iterator defines the out edges of vertex +v+. This
     # method must be defined by concrete graph classes. Its defines the BGL
     # IncidenceGraph concept.
+    # @param v a vertex of the graph
     #
     def each_adjacent(v) # :yields: v
       raise NotImplementedError
     end
 
-    # The each_edge iterator should provide efficient access to all edges of the
-    # graph. Its defines the EdgeListGraph concept.
+    # The +each_edge+ iterator should provide efficient access to all edges of the
+    # graph. Its defines the BGL EdgeListGraph concept.
     #
-    # 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 not yield
+    # This method must *not* be defined by concrete graph classes, because it
+    # can be implemented using {#each_vertex} and {#each_adjacent}. However for
+    # undirected graphs the function is inefficient because we must not yield
     # (v,u) if we already visited edge (u,v).
-    #
     def each_edge(&block)
       if directed?
         each_vertex do |u|
@@ -170,15 +180,14 @@ module RGL
     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
+    # 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).
-    #
+    # @param (see #each_adjacent)
     def has_vertex?(v)
       include?(v) # inherited from enumerable
     end
@@ -189,20 +198,20 @@ module RGL
       num_vertices.zero?
     end
 
-    # Return the array of vertices. Synonym for #to_a inherited by Enumerable.
-    #
+    # Synonym for #to_a inherited by Enumerable.
+    # @return [Array] of vertices
     def vertices
       to_a
     end
 
-    # Returns the class for edges: DirectedEdge or UnDirectedEdge.
+    # @return [Class] the class for edges: {Edge::DirectedEdge} or {Edge::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.
+    # @return [Array] of edges (DirectedEdge or UnDirectedEdge) of the graph
+    # It uses {#each_edge} to compute the edges
     def edges
       result = []
       c = edge_class
@@ -210,8 +219,8 @@ module RGL
       result
     end
 
-    # Returns an array of vertices adjacent to vertex _v_.
-    #
+    # @return [Array] of vertices adjacent to vertex +v+.
+    # @param (see #each_adjacent)
     def adjacent_vertices(v)
       r = []
       each_adjacent(v) { |u| r << u }
@@ -219,15 +228,16 @@ module RGL
     end
 
     # Returns the number of out-edges (for directed graphs) or the number of
-    # incident edges (for undirected graphs) of vertex _v_.
-    #
+    # incident edges (for undirected graphs) of vertex +v+.
+    # @return [int]
+    # @param (see #each_adjacent)
     def out_degree(v)
       r = 0
       each_adjacent(v) { |u| r += 1 }
       r
     end
 
-    # Returns the number of vertices.
+    # @return [int] the number of vertices
     #
     def size # Why not in Enumerable?
       inject(0) { |n, v| n + 1 }
@@ -235,7 +245,7 @@ module RGL
 
     alias num_vertices size
 
-    # Returns the number of edges.
+    # @return [int] the number of edges
     #
     def num_edges
       r = 0
@@ -244,13 +254,14 @@ module RGL
     end
 
     # Utility method to show a string representation of the edges of the graph.
-    #
+    # @return [String]
     def to_s
       edges.collect {|e| e.to_s}.sort.join
     end
 
-    # Two graphs are equal iff they have equal directed? property as well as vertices and edges sets.
-    #
+    # Two graphs are equal iff they have equal directed? property as well as
+    # vertices and edges sets.
+    # @param [Graph] other
     def eql?(other)
       equal?(other) || eql_graph?(other)
     end

data/lib/rgl/bellman_ford.rb

@@ -39,9 +39,10 @@ module RGL
 
     # Finds the shortest path form the _source_ to every other vertex of the graph.
     #
-    # Returns the shortest paths map that contains the shortest path (if it exists) from the source to any vertex of the
-    # graph.
+    # Returns the shortest paths map that contains the shortest path (if it
+    # exists) from the source to any vertex of the graph.
     #
+    # @return [Hash[Object,Array]]
     def shortest_paths(source)
       init(source)
       relax_edges
@@ -102,7 +103,7 @@ module RGL
     #
     # Raises ArgumentError or the graph has negative-weight cycles. This behavior can be overridden my a custom handler
     # for visitor's _edge_not_minimized_ event.
-    #
+    # @return [Hash[Object,Array]]
     def bellman_ford_shortest_paths(edge_weights_map, source, visitor = BellmanFordVisitor.new(self))
       BellmanFordAlgorithm.new(self, edge_weights_map, visitor).shortest_paths(source)
     end

data/lib/rgl/bidirectional.rb

@@ -28,7 +28,7 @@ module RGL
 
     # Returns the number of in-edges (for directed graphs) or the number of
     # incident edges (for undirected graphs) of vertex _v_.
-    #
+    # @return [int]
     def in_degree(v)
       r = 0
       each_in_neighbor(v) { |u| r += 1 }
@@ -37,7 +37,7 @@ module RGL
 
     # Returns the number of in-edges plus out-edges (for directed graphs) or the
     # number of incident edges (for undirected graphs) of vertex _v_.
-    #
+    # @return [int]
     def degree(v)
       in_degree(v) + out_degree(v)
     end

data/lib/rgl/bipartite.rb

@@ -10,7 +10,7 @@ module RGL
     #
     # Returns an array of two disjoint vertices sets (represented as arrays) if the graph is bipartite. Otherwise,
     # returns nil.
-    #
+    # @return [Array]
     def bipartite_sets
       raise NotUndirectedError.new('bipartite sets can only be found for an undirected graph') if directed?
 

data/lib/rgl/condensation.rb

@@ -6,14 +6,14 @@ module RGL
 
   module Graph
 
-    # Returns an RGL::ImplicitGraph where the strongly connected components of
+    # Returns an {ImplicitGraph} where the strongly connected components of
     # this graph are condensed into single nodes represented by Set instances
     # containing the members of each strongly connected component. Edges
     # between the different strongly connected components are preserved while
     # edges within strongly connected components are omitted.
     #
-    # Raises RGL::NotDirectedError if run on an undirected graph.
-    #
+    # Raises {NotDirectedError} if run on an undirected graph.
+    # @return ImplicitGraph
     def condensation_graph
       raise NotDirectedError,
             "condensation_graph only supported for directed graphs" unless directed?

data/lib/rgl/connected_components.rb

@@ -38,7 +38,7 @@ module RGL
       yield comp unless comp.empty?
     end
 
-    # This GraphVisitor is used by strongly_connected_components to compute
+    # This {GraphVisitor} is used by {#strongly_connected_components} to compute
     # the strongly connected components of a directed graph.
     #
     class TarjanSccVisitor < DFSVisitor
@@ -103,7 +103,7 @@ module RGL
     # 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.
+    # algorithm with the help of the {DFSVisitor} {TarjanSccVisitor}.
     #
     # === Definition
     #
@@ -128,10 +128,10 @@ module RGL
     #   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.
-    #
+    # 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+.
+    # @return [TarjanSccVisitor]
     def strongly_connected_components
       raise NotDirectedError,
             "strong_components only works for directed graphs." unless directed?