rgl 0.4.0 → 0.5.0

data/lib/rgl/adjacency.rb

@@ -1,15 +1,15 @@
 # adjacency.rb
-# 
-# $Id: adjacency.rb,v 1.12 2008/08/23 05:37:05 javanthropus Exp $
-# 
+#
+# $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
+# 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
+# Set. This can be configured by the client, however, when an AdjacencyGraph
 # is created.
 
 require 'rgl/mutable'
@@ -25,156 +25,159 @@ module RGL
     #
     #  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)
+    #
+    def self.[](*a)
       result = new
-      0.step(a.size-1, 2) { |i| result.add_edge(a[i], a[i+1]) }
+      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 its edgelist
-    # class the given class.  The default edgelist class is Set, to ensure
+    # 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.
-    def initialize (edgelist_class = Set, *other_graphs)
+    #
+    def initialize(edgelist_class = Set, *other_graphs)
       @edgelist_class = edgelist_class
-      @vertice_dict   = Hash.new
+      @vertices_dict = Hash.new
       other_graphs.each do |g|
-        g.each_vertex {|v| add_vertex v}
-        g.each_edge {|v,w| add_edge v,w}
+        g.each_vertex { |v| add_vertex v }
+        g.each_edge { |v, w| add_edge v, w }
       end
     end
 
-    # Copy internal vertice_dict
+    # Copy internal vertices_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
+      @vertices_dict = orig.instance_eval { @vertices_dict }.dup
+      @vertices_dict.keys.each do |v|
+        @vertices_dict[v] = @vertices_dict[v].dup
       end
     end
 
-    # Iterator for the keys of the vertice list hash.
-
-    def each_vertex (&b)
-      @vertice_dict.each_key(&b)
+    # Iterator for the keys of the vertices list hash.
+    #
+    def each_vertex(&b)
+      @vertices_dict.each_key(&b)
     end
 
-    def each_adjacent (v, &b)			# :nodoc:
-      adjacency_list = (@vertice_dict[v] or
-        raise NoVertexError, "No vertex #{v}.")
+    def each_adjacent(v, &b) # :nodoc:
+      adjacency_list = (@vertices_dict[v] or raise NoVertexError, "No vertex #{v}.")
       adjacency_list.each(&b)
     end
 
     # Returns true.
-
+    #
     def directed?
       true
     end
 
     # Complexity is O(1), because the vertices are kept in a Hash containing
     # as values the lists of adjacent vertices of _v_.
-
+    #
     def has_vertex? (v)
-      @vertice_dict.has_key?(v)
+      @vertices_dict.has_key?(v)
     end
 
-    # Complexity is O(1), if a Set is used as adjacency list.  Otherwise,
+    # Complexity is O(1), if a Set is used as adjacency list. Otherwise,
     # complexity is O(out_degree(v)).
     #
     # ---
     # MutableGraph interface.
-
+    #
     def has_edge? (u, v)
-      has_vertex?(u) and @vertice_dict[u].include?(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
     # nothing.
-
-    def add_vertex (v)
-      @vertice_dict[v] ||= @edgelist_class.new
+    #
+    def add_vertex(v)
+      @vertices_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
+    #
+    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)
+      @vertices_dict.delete(v)
 
-    def remove_vertex (v)
-      @vertice_dict.delete(v)
-          
       # remove v from all adjacency lists
-
-      @vertice_dict.each_value { |adjList| adjList.delete(v) }
+      @vertices_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?
+    #
+    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
-    # class is expected to have a new contructor which accepts an enumerable as
+    # class is expected to have a new constructor 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
+      @vertices_dict.keys.each do |v|
+        @vertices_dict[v] = klass.new @vertices_dict[v].to_a
       end
     end
 
     protected
 
-    def basic_add_edge (u, v)
-      @vertice_dict[u].add(v)
+    def basic_add_edge(u, v)
+      @vertices_dict[u].add(v)
     end
 
-  end		# class DirectedAdjacencyGraph
+  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,
+  # 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
 
-  class AdjacencyGraph < DirectedAdjacencyGraph 
-
-    def directed?				# Always returns false.
+    # Always returns false.
+    #
+    def directed?
       false
     end
-        
-    # Also removes (v,u)
 
-    def remove_edge (u, v)
+    # Also removes (v,u)
+    #
+    def remove_edge(u, v)
       super
-      @vertice_dict[v].delete(u) unless @vertice_dict[v].nil?
+      @vertices_dict[v].delete(u) unless @vertices_dict[v].nil?
     end
 
     protected
 
-    def basic_add_edge (u,v)
+    def basic_add_edge(u, v)
       super
-      @vertice_dict[v].add(u)			# Insert backwards edge
+      @vertices_dict[v].add(u) # Insert backwards edge
     end
 
-  end		# class AdjacencyGraph
+  end # class AdjacencyGraph
 
   module Graph
 
-    # Convert a general graph to an AdjacencyGraph.  If the graph is directed,
+    # Convert a general graph to an AdjacencyGraph. If the graph is directed,
     # returns a DirectedAdjacencyGraph; otherwise, returns an AdjacencyGraph.
-
+    #
     def to_adjacency
       result = (directed? ? DirectedAdjacencyGraph : AdjacencyGraph).new
       each_vertex { |v| result.add_vertex(v) }
-      each_edge { |u,v| result.add_edge(u, v) }
+      each_edge { |u, v| result.add_edge(u, v) }
       result
     end
 
@@ -182,25 +185,26 @@ 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.
-
+    #
     def reverse
       return self unless directed?
       result = DirectedAdjacencyGraph.new
       each_vertex { |v| result.add_vertex v }
-      each_edge { |u,v| result.add_edge(v, u) }
+      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)
+    # 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.
-
+    #
     def to_undirected
       return self unless directed?
       AdjacencyGraph.new(Set, self)
     end
 
-  end		# module Graph
-end		# module RGL
+  end # module Graph
+
+end # module RGL

data/lib/rgl/base.rb

@@ -3,114 +3,144 @@
 # 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.4.0"
+RGL_VERSION = "0.5.0"
 
 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
+  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
   # 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 DirecteEdge or UnDirectedEdge instances are returned
+    # explicitly DirectedEdge or UnDirectedEdge instances are returned
     # (i.e. Graph#edges).
+    #
     class DirectedEdge
-      attr_accessor :source, :target
 
+      attr_accessor :source, :target
       # Can be used to create an edge from a two element array.
+      #
       def self.[](*a)
-        new(a[0],a[1])
+        new(a[0], a[1])
       end
 
       # Create a new DirectedEdge with source _a_ and target _b_.
-      def initialize (a,b)
-        @source, @target = a,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
+        (source == edge.source) && (target == edge.target)
       end
+
       alias == eql?
 
+      def hash
+        source.hash ^ target.hash
+      end
+
       # 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
+      #
+      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
+      #
+      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
+
+    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)
+        super || ((target == edge.source) && (source == edge.target))
       end
-      
-      def hash
-        source.hash ^ target.hash
-      end
-      
+
       # UnDirectedEdge[1,2].to_s == "(1=2)"
-      def to_s; "(#{source}=#{target})"; end
+      #
+      def to_s
+        "(#{source}=#{target})"
+      end
+
     end
 
-  end                           # Edge
+  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.
+  # 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
-	# other functions are derived from these fundamental iterators, i.e.
-	# num_vertices or num_edges.
+  # 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 by concrete graph classes. It defines the BGL VertexListGraph
     # concept.
-    def each_vertex () # :yields: v
+    #
+    def each_vertex() # :yields: v
       raise NotImplementedError
     end
 
     # 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.
-    def each_adjacent (v) # :yields: v
+    #
+    def each_adjacent(v) # :yields: v
       raise NotImplementedError
     end
 
@@ -121,109 +151,161 @@ module RGL
     # can be implemented using each_vertex and each_adjacent. However for
     # undirected graph the function is inefficient because we must not yield
     # (v,u) if we already visited edge (u,v).
-    def each_edge (&block)
+    #
+    def each_edge(&block)
       if directed?
-        each_vertex { |u|
-          each_adjacent(u) { |v| yield u,v }
-        }
+        each_vertex do |u|
+          each_adjacent(u) { |v| yield u, v }
+        end
       else
-        each_edge_aux(&block)       # concrete graphs should to this better
+        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
+    #
+    def each(&block)
+      each_vertex(&block)
+    end
 
     # Is the graph directed? The default returns false.
-    def directed?; false; end
+    #
+    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 be better here (see AdjacencyGraph).
-    def has_vertex?(v); include?(v); end    # inherited from enumerable
+    #
+    def has_vertex?(v)
+      include?(v) # inherited from enumerable
+    end
 
     # Returns true if the graph has no vertices, i.e. num_vertices == 0.
-    # ---
-    # === accessing vertices and edges
-    def empty?; num_vertices.zero?; end
+    #
+    def empty?
+      num_vertices.zero?
+    end
 
     # Return the array of vertices. Synonym for #to_a inherited by Enumerable.
-    def vertices; to_a; end
+    #
+    def vertices
+      to_a
+    end
 
     # Returns the class for edges: DirectedEdge or UnDirectedEdge.
-    def edge_class; directed? ? DirectedEdge : UnDirectedEdge; end
+    #
+    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) }
+      each_edge { |u, v| result << c.new(u, v) }
       result
     end
 
     # Returns an array of vertices adjacent to vertex _v_.
-    def adjacent_vertices (v)
+    #
+    def adjacent_vertices(v)
       r = []
-      each_adjacent(v) {|u| r << u}
+      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)
+    # incident edges (for undirected graphs) of vertex _v_.
+    #
+    def out_degree(v)
       r = 0
-      each_adjacent(v) { |u| r += 1}
+      each_adjacent(v) { |u| r += 1 }
       r
     end
 
     # Returns the number of vertices.
-    def size()                  # Why not in Enumerable?
+    #
+    def size # Why not in Enumerable?
       inject(0) { |n, v| n + 1 }
     end
-		alias :num_vertices :size
+
+    alias num_vertices size
 
     # Returns the number of edges.
-    def num_edges; r = 0; each_edge {|u,v| r +=1}; r; end
+    #
+    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
-
-    # 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
+      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.
+    #
+    def eql?(other)
+      equal?(other) || eql_graph?(other)
     end
+
     alias == eql?
 
     private
 
+    def eql_graph?(other)
+      other.is_a?(Graph) && directed? == other.directed? && eql_vertices_set?(other) && eql_edges_set?(other)
+    end
+
+    def eql_vertices_set?(other)
+      other_num_vertices = 0
+
+      other.each_vertex do |v|
+        if has_vertex?(v)
+          other_num_vertices += 1
+        else
+          return false
+        end
+      end
+
+      other_num_vertices == num_vertices
+    end
+
+    def eql_edges_set?(other)
+      other_num_edges = 0
+
+      other.each_edge do |u, v|
+        if has_edge?(u, v)
+          other_num_edges += 1
+        else
+          return false
+        end
+      end
+
+      other_num_edges == num_edges
+    end
+
     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
+
+      each_vertex do |u|
+        each_adjacent(u) do |v|
+          edge = UnDirectedEdge.new(u, v)
+
+          unless visited.has_key?(edge)
+            visited[edge] = true
             yield u, v
           end
-        }
-      }
+        end
+      end
     end
-  end                           # module Graph
 
-end                             # module RGL
+  end # module Graph
 
+end # module RGL