puppet 0.18.4 → 0.22.4

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

@@ -0,0 +1,34 @@
+#--
+# 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.
+#++
+
+GRATR_VERSION = "0.4.1"
+
+module GRATR
+  class NoVertexError      < IndexError;   end
+  class NoEdgeError        < IndexError;   end
+end

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

@@ -0,0 +1,116 @@
+#--
+# 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.
+#++
+
+
+require 'set'
+
+module GRATR
+  module Graph    
+    # Biconnected is a module for adding the biconnected algorithm to 
+    # UndirectedGraphs
+    module Biconnected
+
+      # biconnected computes the biconnected subgraphs
+      # of a graph using Tarjan's algorithm based on DFS. See: Robert E. Tarjan
+      # _Depth_First_Search_and_Linear_Graph_Algorithms_. SIAM Journal on 
+      # Computing, 1(2):146-160, 1972
+      #
+      # The output of the algorithm is a pair, the first value is an 
+      # array of biconnected subgraphs. The second is the set of
+      # articulation vertices.
+      #
+      # A connected graph is biconnected if the removal of any single vertex 
+      # (and all edges incident on that vertex) cannot disconnect the graph.
+      # More generally, the biconnected components of a graph are the maximal
+      # subsets of vertices such that the removal of a vertex from a particular
+      # component will not disconnect the component. Unlike connected components,
+      # vertices may belong to multiple biconnected components: those vertices
+      # that belong to more than one biconnected component are called articulation
+      # points or, equivalently, cut vertices. Articulation points are vertices
+      # whose removal would increase the number of connected components in the graph.
+      # Thus, a graph without articulation points is biconnected.
+      def biconnected
+        dfs_num     = 0
+        number      = {}; predecessor = {}; low_point   = {}
+        stack       = []; result      = []; articulation= []
+
+        root_vertex  = Proc.new {|v| predecessor[v]=v }
+        enter_vertex = Proc.new {|u| number[u]=low_point[u]=(dfs_num+=1) }
+        tree_edge  = Proc.new do |e|
+          stack.push(e)
+          predecessor[e.target] = e.source
+        end
+        back_edge  = Proc.new do |e|
+          if e.target != predecessor[e.source]
+            stack.push(e)
+            low_point[e.source] = [low_point[e.source], number[e.target]].min
+          end
+        end
+        exit_vertex = Proc.new do |u|
+          parent = predecessor[u]
+          is_articulation_point = false
+          if number[parent] > number[u]
+            parent = predecessor[parent]
+            is_articulation_point = true
+          end
+          if parent == u
+            is_articulation_point = false if (number[u] + 1) == number[predecessor[u]]
+          else
+            low_point[parent] = [low_point[parent], low_point[u]].min
+            if low_point[u] >= number[parent]
+              if number[parent] > number[predecessor[parent]]
+                predecessor[u] = predecessor[parent]
+                predecessor[parent] = u
+              end
+              result << (component = self.class.new)
+              while number[stack[-1].source] >= number[u]
+                component.add_edge!(stack.pop)
+              end
+              component.add_edge!(stack.pop)
+              if stack.empty?
+                predecessor[u] = parent
+                predecessor[parent] = u
+              end
+            end
+          end
+          articulation << u if is_articulation_point
+        end
+
+        # Execute depth first search
+        dfs({:root_vertex  => root_vertex,
+             :enter_vertex => enter_vertex, 
+             :tree_edge    => tree_edge,
+             :back_edge    => back_edge,
+             :exit_vertex  => exit_vertex})
+           
+        [result, articulation]
+      end # biconnected
+
+    end # Biconnected
+
+  end # Graph
+end # GRATR

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

@@ -0,0 +1,123 @@
+#--
+# 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.
+#++
+
+
+require 'puppet/external/gratr/digraph_distance'
+
+module GRATR
+  module Graph
+    module ChinesePostman    
+  
+      # Returns the shortest walk that traverses all arcs at least
+      # once, returning to the specified start node.
+      def closed_chinese_postman_tour(start, weight=nil, zero=0)
+        cost, path, delta = floyd_warshall(weight, zero)
+        return nil unless cp_valid_least_cost? cost, zero
+        positive, negative = cp_unbalanced(delta)
+        f = cp_find_feasible(delta, positive, negative, zero)
+        while cp_improve(f, positive, negative, cost, zero); end
+        cp_euler_circuit(start, f, path)
+      end
+
+    private
+   
+      def cp_euler_circuit(start, f, path) # :nodoc:
+        circuit = [u=v=start]
+        bridge_taken = Hash.new {|h,k| h[k] = Hash.new}
+        until v.nil?
+          if v=f[u].keys.detect {|k| f[u][k] > 0}
+            f[u][v] -= 1
+            circuit << (u = path[u][v]) while u != v 
+          else
+            unless bridge_taken[u][bridge = path[u][start]]
+              v = vertices.detect {|v1| v1 != bridge && edge?(u,v1) && !bridge_taken[u][v1]} || bridge
+              bridge_taken[u][v] = true
+              circuit << v            
+            end
+          end  
+          u=v
+        end; circuit
+      end
+   
+      def cp_cancel_cycle(cost, path, f, start, zero) # :nodoc:
+        u = start; k = nil
+        begin
+          v = path[u][start]
+          k = f[v][u] if cost[u][v] < zero and (k.nil? || k > f[v][u])
+        end until (u=v) != start
+        u = start
+        begin
+          v = path[u][start]
+          cost[u][v] < zero ? f[v][u] -= k : f[u][v] += k
+        end until (u=v) != start
+        true # This routine always returns true to make cp_improve easier
+      end
+    
+      def cp_improve(f, positive, negative, cost, zero) # :nodoc:
+        residual = self.class.new
+        negative.each do |u|
+          positive.each do |v|
+            residual.add_edge!(u,v,cost[u][v])
+            residual.add_edge!(v,u,-cost[u][v]) if f[u][v] != 0
+          end
+        end
+        r_cost, r_path, r_delta = residual.floyd_warshall(nil, zero)
+        i = residual.vertices.detect {|v| r_cost[v][v] and r_cost[v][v] < zero}
+        i ? cp_cancel_cycle(r_cost, r_path, f, i) : false
+      end
+    
+      def cp_find_feasible(delta, positive, negative, zero) # :nodoc:
+        f = Hash.new {|h,k| h[k] = Hash.new}
+        negative.each do |i|
+          positive.each do |j|
+            f[i][j] = -delta[i] < delta[j] ? -delta[i] : delta[j]
+            delta[i] += f[i][j]
+            delta[j] -= f[i][j]
+          end
+        end; f
+      end
+   
+      def cp_valid_least_cost?(c, zero) # :nodoc:
+        vertices.each do |i|
+          vertices.each do |j|
+            return false unless c[i][j] and c[i][j] >= zero
+          end
+        end; true
+      end
+    
+      def cp_unbalanced(delta) # :nodoc:
+        negative = []; positive = []
+        vertices.each do |v|
+          negative << v if delta[v] < 0
+          positive << v if delta[v] > 0
+        end; [positive, negative]  
+      end
+
+    end # Chinese Postman
+  end # Graph
+end # GRATR
+  

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

@@ -0,0 +1,73 @@
+#--
+# 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.
+#++
+
+
+require 'puppet/external/gratr/edge'
+require 'puppet/external/gratr/graph'
+
+module GRATR
+  # This class defines a cycle graph of size n
+  # This is easily done by using the base Graph
+  # class and implemeting the minimum methods needed to
+  # make it work. This is a good example to look
+  # at for making one's own graph classes
+  class Cycle
+    
+    def initialize(n) @size = n;       end
+    def directed?()     false;           end
+    def vertices()    (1..@size).to_a; end
+    def vertex?(v)    v > 0 and v <= @size; end
+    def edge?(u,v=nil)
+      u, v = [u.source, v.target] if u.kind_of? GRATR::Edge
+      vertex?(u) && vertex?(v) && ((v-u == 1) or (u==@size && v=1))
+    end
+    def edges() Array.new(@size) {|i| GRATR::UndirectedEdge[i+1, (i+1)==@size ? 1 : i+2]}; end
+  end
+  
+  # This class defines a complete graph of size n
+  # This is easily done by using the base Graph
+  # class and implemeting the minimum methods needed to
+  # make it work. This is a good example to look
+  # at for making one's own graph classes
+  class Complete < Cycle
+    def initialize(n) @size = n; @edges = nil; end
+    def edges
+      return @edges if @edges      # Cache edges
+      @edges = []
+      @size.times do |u|
+        @size.times {|v| @edges << GRATR::UndirectedEdge[u+1, v+1]}
+      end; @edges
+    end
+    def edge?(u,v=nil)
+      u, v = [u.source, v.target] if u.kind_of? GRATR::Edge
+      vertex?(u) && vertex?(v)
+    end
+  end              # Complete
+  
+  
+  
+end                # GRATR

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

@@ -0,0 +1,92 @@
+#--
+# 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 Comparability
+      
+      # A comparability graph is an UndirectedGraph that has a transitive
+      # orientation. This returns a boolean that says if this graph
+      # is a comparability graph.
+      def comparability?() gamma_decomposition[1]; end
+      
+      # Returns an array with two values, the first being a hash of edges 
+      # with a number containing their class assignment, the second valud
+      # is a boolean which states whether or not the graph is a 
+      # comparability graph
+      #
+      # Complexity in time O(d*|E|) where d is the maximum degree of a vertex
+      # Complexity in space O(|V|+|E|)
+      def gamma_decomposition
+        k = 0; comparability=true; classification={}
+        edges.map {|edge| [edge.source,edge.target]}.each do |e|
+          if classification[e].nil?
+            k += 1
+            classification[e] = k; classification[e.reverse] = -k
+            comparability &&= gratr_comparability_explore(e, k, classification)
+          end
+        end; [classification, comparability]
+      end
+      
+      # Returns one of the possible transitive orientations of 
+      # the UndirectedGraph as a Digraph
+      def transitive_orientation(digraph_class=Digraph)
+        raise NotImplementError
+      end
+      
+     private
+     
+      # Taken from Figure 5.10, on pg. 130 of Martin Golumbic's, _Algorithmic_Graph_
+      # _Theory_and_Perfect_Graphs.
+      def gratr_comparability_explore(edge, k, classification, space='')
+        ret = gratr_comparability_explore_inner(edge, k, classification, :forward, space)
+        gratr_comparability_explore_inner(edge.reverse, k, classification, :backward, space) && ret
+      end
+      
+      def gratr_comparability_explore_inner(edge, k, classification, direction,space)
+        comparability = true  
+        adj_target = adjacent(edge[1])
+        adjacent(edge[0]).select do |mt|
+          (classification[[edge[1],mt]] || k).abs < k or
+          not adj_target.any? {|adj_t| adj_t == mt} 
+        end.each do |m|
+          e = (direction == :forward) ? [edge[0], m] : [m,edge[0]]
+          if classification[e].nil?
+            classification[e] = k
+            classification[e.reverse] = -k
+            comparability = gratr_comparability_explore(e, k, classification, '  '+space) && comparability
+          elsif classification[e] == -k
+            classification[e] = k
+            gratr_comparability_explore(e, k, classification, '  '+space)
+            comparability = false
+          end
+        end; comparability
+      end # gratr_comparability_explore_inner
+      
+    end # Comparability
+  end # Graph
+end # GRATR

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

@@ -0,0 +1,116 @@
+#--
+# 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/graph'
+require 'puppet/external/gratr/search'
+require 'puppet/external/gratr/adjacency_graph'
+require 'puppet/external/gratr/strong_components'
+require 'puppet/external/gratr/digraph_distance'
+require 'puppet/external/gratr/chinese_postman'
+
+module GRATR
+  #
+  # Digraph is a directed graph which is a finite set of vertices
+  # and a finite set of edges connecting vertices. It cannot contain parallel
+  # edges going from the same source vertex to the same target. It also
+  # cannot contain loops, i.e. edges that go have the same vertex for source 
+  # and target.
+  #
+  # DirectedPseudoGraph is a class that allows for parallel edges, and a
+  # DirectedMultiGraph is a class that allows for parallel edges and loops
+  # as well.
+  class Digraph
+    include AdjacencyGraph
+    include Graph::Search
+    include Graph::StrongComponents
+    include Graph::Distance
+    include Graph::ChinesePostman
+  
+    def initialize(*params)
+      raise ArgumentError if params.any? do |p| 
+       !(p.kind_of? GRATR::Graph or p.kind_of? Array)
+      end if self.class == GRATR::Digraph
+      super(*params)
+    end 
+
+    # A directed graph is directed by definition
+    def directed?() true; end
+
+    # A digraph uses the Edge class for edges
+    def edge_class() @parallel_edges ? GRATR::MultiEdge : GRATR::Edge; end
+
+    # Reverse all edges in a graph
+    def reversal
+      return new(self) unless directed?
+      result = self.class.new
+      edges.inject(result) {|a,e| a << e.reverse}
+      vertices.each { |v| result.add_vertex!(v) unless result.vertex?(v) }
+      result
+    end
+
+    # Return true if the Graph is oriented.
+    def oriented?
+      e = edges
+      re = e.map {|x| x.reverse}
+      not e.any? {|x| re.include?(x)}
+    end
+    
+    # Balanced is when the out edge count is equal to the in edge count
+    def balanced?(v) out_degree(v) == in_degree(v); end
+    
+    # Returns out_degree(v) - in_degree(v)
+    def delta(v) out_degree(v) - in_degree(v); end
+          
+  end
+
+  # DirectedGraph is just an alias for Digraph should one desire
+  DirectedGraph = Digraph
+
+  # This is a Digraph that allows for parallel edges, but does not
+  # allow loops
+  class DirectedPseudoGraph < Digraph
+    def initialize(*params)
+      raise ArgumentError if params.any? do |p| 
+       !(p.kind_of? GRATR::Graph or p.kind_of? Array)
+      end
+      super(:parallel_edges, *params)
+    end 
+  end
+
+  # This is a Digraph that allows for parallel edges and loops
+  class DirectedMultiGraph < Digraph
+    def initialize(*params)
+      raise ArgumentError if params.any? do |p| 
+       !(p.kind_of? GRATR::Graph or p.kind_of? Array)
+      end
+      super(:parallel_edges, :loops, *params)
+    end 
+  end
+
+end