puppet 0.24.1 → 0.24.2

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

@@ -1,123 +0,0 @@
-#--
-# 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

@@ -1,73 +0,0 @@
-#--
-# 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

@@ -1,92 +0,0 @@
-#--
-# 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

@@ -1,116 +0,0 @@
-#--
-# 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

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

@@ -1,185 +0,0 @@
-#--
-# 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