gratr 0.4.2

data/lib/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 '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/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 'gratr/edge'
+require '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::Arc
+      vertex?(u) && vertex?(v) && ((v-u == 1) or (u==@size && v=1))
+    end
+    def edges() Array.new(@size) {|i| GRATR::Edge[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::Edge[u+1, v+1]}
+      end; @edges
+    end
+    def edge?(u,v=nil)
+      u, v = [u.source, v.target] if u.kind_of? GRATR::Arc
+      vertex?(u) && vertex?(v)
+    end
+  end              # Complete
+  
+  
+  
+end                # GRATR

data/lib/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/gratr/digraph.rb

@@ -0,0 +1,113 @@
+#--
+# 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 'gratr/edge'
+require 'gratr/graph'
+require 'gratr/search'
+require 'gratr/adjacency_graph'
+require 'gratr/strong_components'
+require 'gratr/digraph_distance'
+require '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 Arc class for edges
+    def edge_class() @parallel_edges ? GRATR::MultiArc : GRATR::Arc; end
+
+    # Reverse all edges in a graph
+    def reversal
+      return new(self) unless directed?
+      edges.inject(self.class.new) {|a,e| a << e.reverse}
+    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/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 Arc. 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 Arc. 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 Arc. 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 Arc is passed to it, if it's nil it will just use
+      # the value in the label for the Arc, otherwise the weight is
+      # determined by applying the [] operator to the value in the 
+      # label for the Arc
+      #
+      # 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