puppet 0.18.4 → 0.22.4

data/lib/puppet/external/gratr/digraph_distance.rb

@@ -0,0 +1,185 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# 
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice(s),
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+#     * Neither the name of the Shawn Garbett nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+module GRATR
+  module Graph
+    module Distance
+              
+      # Shortest path from Jorgen Band-Jensen and Gregory Gutin,
+      # _DIGRAPHS:_Theory,_Algorithms_and_Applications, pg 53-54
+      #
+      # Requires that the graph be acyclic. If the graph is not
+      # acyclic, then see dijkstras_algorithm or bellman_ford_moore
+      # for possible solutions.
+      #
+      # start is the starting vertex 
+      # weight can be a Proc, or anything else is accessed using the [] for the
+      #     the label or it defaults to using
+      #     the value stored in the label for the Edge. If it is a Proc it will 
+      #     pass the edge to the proc and use the resulting value.
+      # zero is used for math system with a different definition of zero
+      #
+      # Returns a hash with the key being a vertex and the value being the
+      # distance. A missing vertex from the hash is an infinite distance
+      #
+      # Complexity O(n+m)
+      def shortest_path(start, weight=nil, zero=0)
+        dist = {start => zero}; path = {}
+        topsort(start) do |vi|
+          next if vi == start
+          dist[vi],path[vi] = adjacent(vi, :direction => :in).map do |vj|
+            [dist[vj] + cost(vj,vi,weight), vj] 
+          end.min {|a,b| a[0] <=> b[0]}
+        end; 
+        dist.keys.size == vertices.size ? [dist,path] : nil
+      end # shortest_path    
+    
+      # Algorithm from Jorgen Band-Jensen and Gregory Gutin,
+      # _DIGRAPHS:_Theory,_Algorithms_and_Applications, pg 53-54
+      #  
+      # Finds the distances from a given vertex s in a weighted digraph
+      # to the rest of the vertices, provided all the weights of arcs
+      # are non-negative. If negative arcs exist in the graph, two 
+      # basic options exist, 1) modify all weights to be positive by
+      # using an offset, or 2) use the bellman_ford_moore algorithm.
+      # Also if the graph is acyclic, use the shortest_path algorithm.
+      #
+      # weight can be a Proc, or anything else is accessed using the [] for the
+      #     the label or it defaults to using
+      #     the value stored in the label for the Edge. If it is a Proc it will 
+      #     pass the edge to the proc and use the resulting value.
+      #  
+      # zero is used for math system with a different definition of zero
+      #
+      # Returns a hash with the key being a vertex and the value being the
+      # distance. A missing vertex from the hash is an infinite distance
+      #
+      # O(n*log(n) + m) complexity
+      def dijkstras_algorithm(s, weight = nil, zero = 0)
+        q = vertices; distance = { s => zero }; path = {}
+        while not q.empty?
+          v = (q & distance.keys).inject(nil) {|a,k| (!a.nil?) && (distance[a] < distance[k]) ? a : k} 
+          q.delete(v)
+          (q & adjacent(v)).each do |u|
+            c = cost(v,u,weight)
+            if distance[u].nil? or distance[u] > (c+distance[v])
+              distance[u] = c + distance[v]
+              path[u] = v
+            end
+          end
+        end; [distance, path]
+      end # dijkstras_algorithm
+
+      # Algorithm from Jorgen Band-Jensen and Gregory Gutin,
+      # _DIGRAPHS:_Theory,_Algorithms_and_Applications, pg 56-58
+      #  
+      # Finds the distances from a given vertex s in a weighted digraph
+      # to the rest of the vertices, provided the graph has no negative cycle.
+      # If no negative weights exist, then dijkstras_algorithm is more
+      # efficient in time and space. Also if the graph is acyclic, use the
+      # shortest_path algorithm.
+      #
+      # weight can be a Proc, or anything else is accessed using the [] for the
+      #     the label or it defaults to using
+      #     the value stored in the label for the Edge. If it is a Proc it will 
+      #     pass the edge to the proc and use the resulting value.
+      #  
+      # zero is used for math system with a different definition of zero
+      #
+      # Returns a hash with the key being a vertex and the value being the
+      # distance. A missing vertex from the hash is an infinite distance
+      #
+      # O(nm) complexity   
+      def bellman_ford_moore(start, weight = nil, zero = 0)
+        distance = { start => zero }; path = {}
+        2.upto(vertices.size) do
+          edges.each do |e|
+            u,v = e[0],e[1]
+            unless distance[u].nil?
+              c = cost(u, v, weight)+distance[u]
+              if distance[v].nil? or c < distance[v]
+                distance[v] = c
+                path[v] = u
+              end 
+            end        
+          end
+        end; [distance, path]
+      end # bellman_ford_moore
+    
+      # This uses the Floyd-Warshall algorithm to efficiently find
+      # and record shortest paths at the same time as establishing
+      # the costs for all vertices in a graph.
+      # See, S.Skiena, "The Algorithm Design Manual", 
+      # Springer Verlag, 1998 for more details.
+      #  
+      # Returns a pair of matrices and a hash of delta values. 
+      # The matrices will be indexed by two vertices and are
+      # implemented as a Hash of Hashes. The first matrix is the cost, the second
+      # matrix is the shortest path spanning tree. The delta (difference of number
+      # of in edges and out edges) is indexed by vertex.
+      #
+      # weight specifies how an edge weight is determined, if it's a
+      # Proc the Edge is passed to it, if it's nil it will just use
+      # the value in the label for the Edge, otherwise the weight is
+      # determined by applying the [] operator to the value in the 
+      # label for the Edge
+      #
+      # zero defines the zero value in the math system used. Defaults
+      # of course, to 0. This allows for no assumptions to be made
+      # about the math system and fully functional duck typing.
+      #
+      # O(n^3) complexity in time.
+      def floyd_warshall(weight=nil, zero=0)
+        c     = Hash.new {|h,k| h[k] = Hash.new}
+        path  = Hash.new {|h,k| h[k] = Hash.new}
+        delta = Hash.new {|h,k| h[k] = 0}
+        edges.each do |e| 
+          delta[e.source] += 1
+          delta[e.target] -= 1
+          path[e.source][e.target] = e.target      
+          c[e.source][e.target] = cost(e, weight)
+        end
+        vertices.each do |k|
+          vertices.each do |i|
+            if c[i][k]
+              vertices.each do |j|
+                if c[k][j] && 
+                  (c[i][j].nil? or c[i][j] > (c[i][k] + c[k][j]))
+                  path[i][j] = path[i][k]
+                  c[i][j] = c[i][k] + c[k][j]
+                  return nil if i == j and c[i][j] < zero
+                end
+              end
+            end  
+          end
+        end
+        [c, path, delta]
+      end # floyd_warshall
+           
+    end # Distance
+  end # Graph
+end # GRATR

data/lib/puppet/external/gratr/dot.rb

@@ -0,0 +1,90 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# Copyright (c) 2002,2004,2005 by Horst Duchene
+# 
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice(s),
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+#     * Neither the name of the Shawn Garbett nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+#
+# Minimal Dot support, based on Dave Thomas's dot module (included in rdoc).
+# rdot.rb is a modified version which also contains support for undirected
+# graphs.
+
+require 'puppet/external/gratr/rdot'
+
+module GRATR
+  module Graph
+ 
+    # Return a DOT::DOTDigraph for directed graphs or a DOT::DOTSubgraph for an
+    # undirected Graph.  _params_ can contain any graph property specified in
+    # rdot.rb. If an edge or vertex label is a kind of Hash then the keys
+    # which match +dot+ properties will be used as well.
+    def to_dot_graph (params = {})
+      params['name'] ||= self.class.name.gsub(/:/,'_')
+      fontsize   = params['fontsize'] ? params['fontsize'] : '8'
+      graph      = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
+      edge_klass = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
+      vertices.each do |v|
+        name = v.to_s
+        params = {'name'     => '"'+name+'"',
+                  'fontsize' => fontsize,
+                  'label'    => name}
+        v_label = vertex_label(v)
+        params.merge!(v_label) if v_label and v_label.kind_of? Hash
+        graph << DOT::DOTNode.new(params)
+      end
+      edges.each do |e|
+        params = {'from'     => '"'+ e.source.to_s + '"',
+                  'to'       => '"'+ e.target.to_s + '"',
+                  'fontsize' => fontsize }
+        e_label = edge_label(e)
+        params.merge!(e_label) if e_label and e_label.kind_of? Hash
+        graph << edge_klass.new(params)
+      end
+      graph
+    end
+    
+    # Output the dot format as a string
+    def to_dot (params={}) to_dot_graph(params).to_s; end
+
+    # Call +dotty+ for the graph which is written to the file 'graph.dot'
+    # in the # current directory.
+    def dotty (params = {}, dotfile = 'graph.dot')
+      File.open(dotfile, 'w') {|f| f << to_dot(params) }
+      system('dotty', dotfile)
+    end
+
+    # Use +dot+ to create a graphical representation of the graph.  Returns the
+    # filename of the graphics file.
+    def write_to_graphic_file (fmt='png', dotfile='graph')
+      src = dotfile + '.dot'
+      dot = dotfile + '.' + fmt
+      
+      File.open(src, 'w') {|f| f << self.to_dot << "\n"}
+      
+      system( "dot -T#{fmt} #{src} -o #{dot}" )
+      dot
+    end
+
+  end                           # module Graph
+end                             # module GRATR

data/lib/puppet/external/gratr/edge.rb

@@ -0,0 +1,145 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# Copyright (c) 2002,2004,2005 by Horst Duchene
+# 
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice(s),
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+#     * Neither the name of the Shawn Garbett nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+
+module GRATR
+
+  # Edge includes classes for representing egdes of directed and
+  # undirected graphs. There is no need for a Vertex class, because any ruby
+  # object can be a vertex of a graph.
+  #
+  # Edge's base is a Struct with a :source, a :target and a :label
+  Struct.new("EdgeBase",:source, :target, :label)
+
+  class Edge < Struct::EdgeBase
+
+    def initialize(p_source,p_target,p_label=nil)
+      super(p_source, p_target, p_label)
+    end
+
+    # Ignore labels for equality
+    def eql?(other) self.class == other.class and target==other.target and source==other.source; end
+
+    # Alias for eql?
+    alias == eql?
+
+    # Returns (v,u) if self == (u,v).
+    def reverse() self.class.new(target, source, label); end
+
+    # Sort support
+    def <=>(rhs) [source,target] <=> [rhs.source,rhs.target]; end
+
+    # Edge.new[1,2].to_s => "(1-2 'label')"
+    def to_s
+      l = label ? " '#{label.to_s}'" : ''
+      "(#{source}-#{target}#{l})"
+    end
+    
+    # Hash is defined in such a way that label is not
+    # part of the hash value
+    def hash() source.hash ^ (target.hash+1); end
+
+    # Shortcut constructor. Instead of Edge.new(1,2) one can use Edge[1,2]
+    def self.[](p_source, p_target, p_label=nil)
+      new(p_source, p_target, p_label)
+    end
+    
+    def inspect() "#{self.class.to_s}[#{source.inspect},#{target.inspect},#{label.inspect}]"; end
+    
+  end
+    
+  # An undirected edge is simply an undirected pair (source, target) used in
+  # undirected graphs. UndirectedEdge[u,v] == UndirectedEdge[v,u]
+  class UndirectedEdge < Edge
+
+    # Equality allows for the swapping of source and target
+    def eql?(other) super or (self.class == other.class and target==other.source and source==other.target); end
+      
+    # Alias for eql?
+    alias == eql?
+
+    # Hash is defined such that source and target can be reversed and the
+    # hash value will be the same
+    #
+    # This will cause problems with self loops
+    def hash() source.hash ^ target.hash; end
+
+    # Sort support
+    def <=>(rhs)
+      [[source,target].max,[source,target].min] <=> 
+      [[rhs.source,rhs.target].max,[rhs.source,rhs.target].min]
+    end
+    
+    # UndirectedEdge[1,2].to_s == "(1=2 'label)"
+    def to_s
+      l = label ? " '#{label.to_s}'" : ''
+      s = source.to_s
+      t = target.to_s
+      "(#{[s,t].min}=#{[s,t].max}#{l})"
+    end
+    
+  end
+  
+  # This module provides for internal numbering of edges for differentiating between mutliple edges
+  module EdgeNumber
+    
+    attr_accessor :number # Used to differentiate between mutli-edges
+    
+    def initialize(p_source,p_target,p_number,p_label=nil)
+      self.number = p_number 
+      super(p_source, p_target, p_label)
+    end
+
+    # Returns (v,u) if self == (u,v).
+    def reverse() self.class.new(target, source, number, label); end
+    def hash() super ^ number.hash; end    
+    def to_s() super + "[#{number}]"; end
+    def <=>(rhs) (result = super(rhs)) == 0 ? number <=> rhs.number : result; end 
+    def inspect() "#{self.class.to_s}[#{source.inspect},#{target.inspect},#{number.inspect},#{label.inspect}]"; end
+    def eql?(rhs) super(rhs) and (rhs.number.nil? or number.nil? or number == rhs.number); end 
+    def ==(rhs) eql?(rhs); end
+
+    # Shortcut constructor. Instead of Edge.new(1,2) one can use Edge[1,2]
+    def self.included(cl)
+      
+      def cl.[](p_source, p_target, p_number=nil, p_label=nil)
+        new(p_source, p_target, p_number, p_label)
+      end
+    end
+
+  end
+  
+  class MultiEdge < Edge
+    include EdgeNumber
+  end
+  
+  class MultiUndirectedEdge < UndirectedEdge
+    include EdgeNumber
+  end
+  
+end

data/lib/puppet/external/gratr/graph.rb

@@ -0,0 +1,303 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# Copyright (c) 2002,2004,2005 by Horst Duchene
+# 
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice(s),
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+#     * Neither the name of the Shawn Garbett nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+
+require 'puppet/external/gratr/edge'
+require 'puppet/external/gratr/labels'
+require 'puppet/external/gratr/graph_api'
+
+module GRATR
+  
+  # Using the functions required by the GraphAPI, it implements all the
+  # basic functions of a Graph class by using only functions in GraphAPI.
+  # An actual implementation still needs to be done, as in Digraph or
+  # UndirectedGraph.
+  module Graph
+    include Enumerable
+    include Labels
+    include GraphAPI
+      
+    # Non destructive version of add_vertex!, returns modified copy of Graph
+    def add_vertex(v, l=nil) x=self.class.new(self); x.add_vertex!(v,l); end
+      
+    # Non destructive version add_edge!, returns modified copy of Graph  
+    def add_edge(u, v=nil, l=nil) x=self.class.new(self); x.add_edge!(u,v,l); end
+      
+    # Non destructive version of remove_vertex!, returns modified copy of Graph
+    def remove_vertex(v) x=self.class.new(self); x.remove_vertex!(v); end  
+
+    # Non destructive version of remove_edge!, returns modified copy of Graph
+    def remove_edge(u,v=nil) x=self.class.new(self); x.remove_edge!(u,v); end
+      
+    # Return Array of adjacent portions of the Graph
+    #  x can either be a vertex an edge.
+    #  options specifies parameters about the adjacency search
+    #   :type can be either :edges or :vertices (default).
+    #   :direction can be :in, :out(default) or :all.
+    #
+    # Note: It is probably more efficently done in implementation.
+    def adjacent(x, options={})
+      d = directed? ? (options[:direction] || :out) : :all
+
+      # Discharge the easy ones first
+      return [x.source] if x.kind_of? Edge and options[:type] == :vertices and d == :in
+      return [x.target] if x.kind_of? Edge and options[:type] == :vertices and d == :out
+      return [x.source, x.target] if x.kind_of? Edge and options[:type] != :edges and d == :all
+
+      (options[:type] == :edges ? edges : to_a).select {|u| adjacent?(x,u,d)}
+    end
+
+    # Add all objects in _a_ to the vertex set.
+    def add_vertices!(*a) a.each {|v| add_vertex! v}; self; end
+      
+    # See add_vertices!
+
+    def add_vertices(*a) x=self.class.new(self); x.add_vertices(*a); self; end
+
+    # Add all edges in the _edges_ Enumerable to the edge set.  Elements of the
+    # Enumerable can be both two-element arrays or instances of DirectedEdge or
+    # UnDirectedEdge. 
+    def add_edges!(*args) args.each { |edge| add_edge!(edge) }; self; end
+      
+    # See add_edge!
+    def add_edges(*a) x=self.class.new(self); x.add_edges!(*a); self; end
+
+    # Remove all vertices specified by the Enumerable a from the graph by
+    # calling remove_vertex!.
+    def remove_vertices!(*a) a.each { |v| remove_vertex! v }; end
+      
+    # See remove_vertices!
+    def remove_vertices(*a) x=self.class.new(self); x.remove_vertices(*a); end
+
+    # Remove all vertices edges by the Enumerable a from the graph by
+    # calling remove_edge!
+    def remove_edges!(*a) a.each { |e| remove_edges! e }; end
+
+    # See remove_edges
+    def remove_edges(*a) x=self.class.new(self); x.remove_edges(*a); end
+
+    # Execute given block for each vertex, provides for methods in Enumerable
+    def each(&block) vertices.each(&block); end
+
+    # Returns true if _v_ is a vertex of the graph.
+    # This is a default implementation that is of O(n) average complexity.
+    # If a subclass uses a hash to store vertices, then this can be
+    # made into an O(1) average complexity operation.
+    def vertex?(v) vertices.include?(v); end  
+    
+    # Returns true if u or (u,v) is an Edge of the graph.
+    def edge?(*arg) edges.include?(edge_convert(*args)); end  
+
+    # Tests two objects to see if they are adjacent.
+    # direction parameter specifies direction of adjacency, :in, :out, or :all(default)
+    # All denotes that if there is any adjacency, then it will return true.
+    # Note that the default is different than adjacent where one is primarily concerned with finding
+    # all adjacent objects in a graph to a given object. Here the concern is primarily on seeing
+    # if two objects touch. For vertexes, any edge between the two will usually do, but the direction
+    # can be specified if need be.
+    def adjacent?(source, target, direction=:all)
+      if source.kind_of? GRATR::Edge
+        raise NoEdgeError unless edge? source
+        if target.kind_of? GRATR::Edge
+          raise NoEdgeError unless edge? target
+          (direction != :out and source.source == target.target) or (direction != :in and source.target == target.source)
+        else
+          raise NoVertexError unless vertex? target
+          (direction != :out and source.source == target)  or (direction != :in and source.target == target)
+        end
+      else
+        raise NoVertexError unless vertex? source
+        if target.kind_of? GRATR::Edge
+          raise NoEdgeError unless edge? target
+          (direction != :out and source == target.target) or (direction != :in and source == target.source)
+        else
+          raise NoVertexError unless vertex? target
+          (direction != :out and edge?(target,source)) or (direction != :in and edge?(source,target))
+        end
+      end
+    end
+
+    # Returns true if the graph has no vertex, i.e. num_vertices == 0.
+    def empty?() vertices.size.zero?; end
+
+    # Returns true if the given object is a vertex or Edge in the Graph.
+    # 
+    def include?(x) x.kind_of?(GRATR::Edge) ? edge?(x) : vertex?(x); end
+
+    # Returns the neighboorhood of the given vertex (or Edge)
+    # This is equivalent to adjacent, but bases type on the type of object.
+    # direction can be :all, :in, or :out 
+    def neighborhood(x, direction = :all)
+      adjacent(x, :direction => direction, :type => ((x.kind_of? GRATR::Edge) ? :edges : :vertices )) 
+    end
+    
+    # Union of all neighborhoods of vertices (or edges) in the Enumerable x minus the contents of x
+    # Definition taken from Jorgen Bang-Jensen, Gregory Gutin, _Digraphs: Theory, Algorithms and Applications_, pg 4
+    def set_neighborhood(x, direction = :all)
+      x.inject(Set.new) {|a,v| a.merge(neighborhood(v,direction))}.reject {|v2| x.include?(v2)}
+    end  
+    
+    # Union of all set_neighborhoods reachable in p edges
+    # Definition taken from Jorgen Bang-Jensen, Gregory Gutin, _Digraphs: Theory, Algorithms and Applications_, pg 46
+    def closed_pth_neighborhood(w,p,direction=:all)
+      if p <= 0
+        w 
+      elsif p == 1
+        (w + set_neighborhood(w,direction)).uniq
+      else
+        n = set_neighborhood(w, direction)
+        (w + n + closed_pth_neighborhood(n,p-1,direction)).uniq
+      end
+    end
+    
+    # Returns the neighboorhoods reachable in p steps from every vertex (or edge)
+    # in the Enumerable x        
+    # Definition taken from Jorgen Bang-Jensen, Gregory Gutin, _Digraphs: Theory, Algorithms and Applications_, pg 46
+    def open_pth_neighborhood(x, p, direction=:all)
+      if    p <= 0
+        x
+      elsif p == 1
+        set_neighborhood(x,direction)
+      else  
+        set_neighborhood(open_pth_neighborhood(x, p-1, direction),direction) - closed_pth_neighborhood(x,p-1,direction)
+      end    
+    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) adjacent(v, :direction => :out).size; 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)  adjacent(v, :direction => :in ).size; end
+
+    # Returns the sum of the number in and out edges for a vertex
+    def degree(v) in_degree(v) + out_degree(v); end
+
+    # Minimum in-degree 
+    def min_in_degree() to_a.map {|v| in_degree(v)}.min; end
+
+    # Minimum out-degree
+    def min_out_degree() to_a.map {|v| out_degree(v)}.min; end
+
+    # Minimum degree of all vertexes
+    def min_degree() [min_in_degree, min_out_degree].min; end
+
+    # Maximum in-degree 
+    def max_in_degree() vertices.map {|v| in_degree(v)}.max; end
+
+    # Maximum out-degree
+    def max_out_degree() vertices.map {|v| out_degree(v)}.max; end
+
+    # Minimum degree of all vertexes
+    def max_degree() [max_in_degree, max_out_degree].max; end
+
+    # Regular
+    def regular?() min_degree == max_degree; end
+
+    # Returns the number of vertices.
+    def size()         vertices.size; end
+
+    # Synonym for size.
+    def num_vertices() vertices.size; end
+
+    # Returns the number of edges.
+    def num_edges()    edges.size; end
+
+    # Utility method to show a string representation of the edges of the graph.
+    def to_s() edges.to_s; end
+
+    # Equality is defined to be same set of edges and directed?
+    def eql?(g) 
+      return false unless g.kind_of? GRATR::Graph
+
+      (g.directed?   == self.directed?)  and 
+      (vertices.sort == g.vertices.sort) and
+      (g.edges.sort  == edges.sort)
+    end
+
+    # Synonym for eql?
+    def ==(rhs) eql?(rhs); end
+
+    # Merge another graph into this one
+    def merge(other)
+      other.vertices.each {|v| add_vertex!(v)      }
+      other.edges.each    {|e| add_edge!(e)         }
+      other.edges.each    {|e| add_edge!(e.reverse) } if directed? and !other.directed? 
+      self 
+    end
+
+    # A synonym for merge, that doesn't modify the current graph
+    def +(other)
+      result = self.class.new(self)
+      case other
+        when GRATR::Graph : result.merge(other)
+        when GRATR::Edge  : result.add_edge!(other)
+        else              result.add_vertex!(other)
+      end
+    end
+
+    # Remove all vertices in the specified right hand side graph
+    def -(other)
+      case  other
+        when GRATR::Graph : induced_subgraph(vertices - other.vertices)
+        when GRATR::Edge  : self.class.new(self).remove_edge!(other)
+        else              self.class.new(self).remove_vertex!(other)
+      end
+    end
+
+    # A synonym for add_edge!
+    def <<(edge) add_edge!(edge); end
+
+    # Return the complement of the current graph
+    def complement
+      vertices.inject(self.class.new) do |a,v|
+        a.add_vertex!(v)
+        vertices.each {|v2| a.add_edge!(v,v2) unless edge?(v,v2) }; a
+      end
+    end
+
+    # Given an array of vertices return the induced subgraph
+    def induced_subgraph(v)
+      edges.inject(self.class.new) do |a,e| 
+        ( v.include?(e.source) and v.include?(e.target) ) ?  (a << e) : a
+      end;
+    end
+    
+    def inspect
+      l = vertices.select {|v| self[v]}.map {|u| "vertex_label_set(#{u.inspect},#{self[u].inspect})"}.join('.')
+      self.class.to_s + '[' + edges.map {|e| e.inspect}.join(', ') + ']' + (l ? '.'+l : '')
+    end
+    
+   private
+    def edge_convert(*args) args[0].kind_of?(GRATR::Edge) ? args[0] : edge_class[*args]; end
+    
+
+  end # Graph
+
+end # GRATR