gratr19 0.4.4

data/tests/TestComplement.rb

@@ -0,0 +1,54 @@
+#--
+# 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 'test/unit'
+require 'gratr/import'
+
+class TestComplement < Test::Unit::TestCase # :nodoc:
+  
+  def test_square
+    x = UndirectedGraph[:a,:b, :b,:c, :c,:d, :d,:a].complement
+    assert_equal 2, x.edges.size
+    assert x.edges.include?(Edge[:a,:c])
+    assert x.edges.include?(Edge[:b,:d])
+  end
+  
+  def test_g1
+    g1 = UndirectedGraph[ :a,:b, :a,:d, :a,:e, :a,:i, :a,:g, :a,:h,
+                          :b,:c, :b,:f,
+                          :c,:d, :c,:h,
+                          :d,:h, :d,:e,
+                          :e,:f,
+                          :f,:g, :f,:h, :f,:i,
+                          :h,:i ].complement
+    assert_equal 19, g1.edges.size
+    
+  end
+
+end

data/tests/TestDigraph.rb

@@ -0,0 +1,333 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# Copyright (c) 2002,2004,2005 by Horst Duchene
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'test/unit'
+require 'gratr/import'
+
+class TestDigraph < Test::Unit::TestCase # :nodoc:
+
+  def setup
+    @single = Digraph[1,2, 2,3, 3,4, 1,2, 2,3, 4,4]
+    @dups   = DirectedPseudoGraph[1,2, 2,3, 3,4, 1,2, 2,3, 4,4]
+    @loops  = DirectedMultiGraph[1,2, 2,3, 3,4, 4,4, 1,2, 2,3]
+  end
+
+  def test_new
+    assert_equal Digraph[1,2, 2,3, 3,4], @single
+    assert_equal DirectedPseudoGraph.new([1,2, 2,3, 3,4, 1,2, 2,3]), @dups
+    assert_equal DirectedMultiGraph.new([1,2, 2,3, 3,4, 4,4, 1,2, 2,3]), @loops
+    assert_raise(ArgumentError) {Digraph.new(:loops)}
+    assert_raise(ArgumentError) {Digraph.new(:parallel_edges)}
+    assert_raise(ArgumentError) {DirectedMultiGraph.new(:loops)}
+    assert_raise(ArgumentError) {DirectedMultiGraph.new(:parallel_edges)}
+    assert_raise(ArgumentError) {DirectedPseudoGraph.new(:loops)}
+    assert_raise(ArgumentError) {DirectedPseudoGraph.new(:parallel_edges)}
+    assert_raise(ArgumentError) {Digraph.new(1)}
+    assert_equal @single, Digraph.new(@single)
+    assert_equal @dups, DirectedPseudoGraph.new(@dups)
+    assert_equal @loops, DirectedMultiGraph.new(@loops)
+    assert_equal Digraph[1,2, 2,3, 3,4], Digraph.new(@loops)
+  end
+
+  def test_edges
+    assert_equal 3,@single.edges.size 
+    assert @single.edges.include?(Arc[1,2])
+    assert @single.edges.include?(Arc[2,3])
+    assert @single.edges.include?(Arc[3,4])
+    assert !@single.edges.include?(Arc[4,4])
+    assert @single.edges.include?(Arc[1,2])
+    assert @single.edges.include?(Arc[2,3])
+    assert !@single.edges.include?(Arc[1,3])
+    assert @single.edge?(2,3)
+    assert !@single.edge?(1,4)
+    assert @single.edge?(Arc[1,2])
+    assert !@single.add_edge!(5,5).edge?(5,5)
+    assert !@single.remove_edge!(5,5).edge?(5,5)
+
+    assert_equal 5,@dups.edges.size 
+    assert @dups.edges.include?(MultiArc[1,2])
+    assert @dups.edges.include?(MultiArc[2,3])
+    assert @dups.edges.include?(MultiArc[3,4])
+    assert !@dups.edges.include?(MultiArc[4,4])
+    assert @dups.edges.include?(MultiArc[1,2])
+    assert @dups.edges.include?(MultiArc[2,3])
+    assert !@dups.edges.include?(MultiArc[1,3])
+    assert @dups.edge?(2,3)
+    assert !@dups.edge?(1,4)
+    assert @dups.edge?(MultiArc[1,2])
+    assert !@dups.add_edge!(5,5).edge?(5,5)
+    assert_raise(ArgumentError) { @dups.remove_edge!(5,5) }
+
+    assert_equal 5,@dups.edges.size 
+    assert @loops.edges.include?(MultiArc[1,2])
+    assert @loops.edges.include?(MultiArc[2,3])
+    assert @loops.edges.include?(MultiArc[3,4])
+    assert @loops.edges.include?(MultiArc[4,4])
+    assert @loops.edges.include?(MultiArc[1,2])
+    assert @loops.edges.include?(MultiArc[2,3])
+    assert !@loops.edges.include?(MultiArc[1,3])
+    assert @loops.edge?(2,3)
+    assert !@loops.edge?(1,4)
+    assert @loops.edge?(MultiArc[1,2])
+    assert @loops.add_edge!(5,5).edge?(5,5)
+    assert_raise(ArgumentError) { @loops.remove_edge!(5,5) }
+
+  end
+
+  def test_vertices
+    assert_equal [1,2,3,4],   @single.vertices.sort
+    assert_equal [1,2,3,4,5], @single.add_vertex!(5).sort
+    assert_equal [1,2,4,5],   @single.remove_vertex!(3).sort
+    assert !@single.vertex?(3)
+    assert !@single.edge?(2,3)
+    assert !@single.edge?(3,4)
+    assert @single.add_vertex(:bogus).vertex?(:bogus)
+    assert !@single.add_vertex(:bogus).vertex?(nil)
+    assert !@single.vertex?(:bogus)
+    @single.add_vertex!(:real)
+    assert @single.vertex?(:real)
+    assert @single.add_edge(:here, :there).edge?(Arc[:here, :there])
+    assert !@single.edge?(Arc[:here, :there])
+    assert !@single.vertex?(:here)
+    assert !@single.vertex?(:there)
+    @single.add_edge!(:here, :there)
+    assert @single.edge?(Arc[:here, :there])
+    assert @single.vertex?(:here)
+    assert @single.vertex?(:there)
+  end
+
+  def test_properties
+    assert @single.directed?
+    assert @single.empty? == false
+    assert Digraph.new.empty? == true
+    assert_equal 4, @single.size 
+    assert_equal 4, @dups.size 
+    assert_equal 4, @loops.size 
+    assert_equal 4, @single.num_vertices
+    assert_equal 4, @dups.num_vertices
+    assert_equal 3, @single.num_edges
+    assert_equal 5, @dups.num_edges
+    assert_equal 6, @loops.num_edges
+    assert @single.oriented?
+    @single.remove_vertex!(4)
+    assert @single.oriented?
+    assert !@loops.oriented?
+    @loops.remove_vertex!(4)
+    assert @loops.oriented?
+  end
+
+  def test_merge
+    @dups.merge(@single)
+    assert_equal 8, @dups.num_edges
+    assert_equal [1,2,3,4],   @dups.vertices.sort
+  end
+
+  def test_operators
+    result = @single + Arc[3,2] 
+    assert_equal 4, @single.size 
+    assert_equal 3, @single.num_edges
+    assert_equal 4, result.size 
+    assert_equal 4, result.num_edges
+
+    result = @single + 5
+    assert_equal 4, @single.size 
+    assert_equal 3, @single.num_edges
+    assert_equal 5, result.size 
+    assert_equal 3, result.num_edges
+
+    result = @single - Arc[4,4]
+    assert_equal 4, @single.size 
+    assert_equal 3, @single.num_edges
+    assert_equal 4, result.size 
+    assert_equal 3, result.num_edges
+
+    e = @loops.edges.detect{|e| e.source == 4 and e.target == 4}
+    result = @loops - e
+    assert_equal 4, @single.size 
+    assert_equal 3, @single.num_edges
+    assert_equal 4, result.size 
+    assert_equal 5, result.num_edges
+
+    result = @single - 4
+    assert_equal 4, @single.size
+    assert_equal 3, @single.num_edges
+    assert_equal 3, result.size 
+    assert_equal 2, result.num_edges
+    
+    @single << Arc[6,1]
+    assert_equal 5, @single.size
+    assert_equal 4, @single.num_edges
+    assert @single.edge?(6,1)
+  end
+
+  def test_reversal
+    reverse = @single.add_vertex!(42).reversal
+    assert_equal [1,2,3,4,42], reverse.vertices.sort
+    assert reverse.edge?(2,1)
+    assert reverse.edge?(3,2)
+    assert reverse.edge?(4,3)
+    assert !reverse.edge?(4,4)
+    assert_equal 3, reverse.num_edges
+    reverse = @loops.reversal
+    assert reverse.edge?(4,4)
+  end
+
+  def test_complement
+    complement = @single.complement 
+    assert_equal [1,2,3,4], complement.vertices.sort
+    assert !complement.edge?(1,1)
+    assert complement.edge?(1,3)
+    assert complement.edge?(1,4)
+    assert complement.edge?(2,1)
+    assert complement.edge?(2,4)
+    assert complement.edge?(3,1)
+    assert complement.edge?(3,2)
+    assert complement.edge?(4,1)
+    assert complement.edge?(4,2)
+    assert complement.edge?(4,3)
+    assert 9, complement.num_edges
+
+    complement = @loops.complement 
+    assert_equal [1,2,3,4], complement.vertices.sort
+    assert complement.edge?(1,1)
+    assert complement.edge?(1,3)
+    assert complement.edge?(1,4)
+    assert complement.edge?(2,1)
+    assert complement.edge?(2,2)
+    assert complement.edge?(2,4)
+    assert complement.edge?(3,1)
+    assert complement.edge?(3,2)
+    assert complement.edge?(3,3)
+    assert complement.edge?(4,1)
+    assert complement.edge?(4,2)
+    assert complement.edge?(4,3)
+    assert 12, complement.num_edges
+  end
+
+  def test_induced_subgraph
+    induced = @single.induced_subgraph([1,2])
+    assert [1,2], induced.vertices.sort
+    assert induced.edge?(1,2)
+    assert 1, induced.num_edges
+  end
+
+  def test_include
+    assert @single.include?(4)
+    assert @dups.include?(4)
+    assert !@dups.include?(5)
+    assert !@single.include?(5)
+    assert @single.include?(Arc[1,2])
+    assert @dups.include?(Arc[1,2])
+  end
+
+  def test_adjacent
+
+    assert @single.adjacent?(2, Arc[1,2])
+    assert_equal [2], @single.adjacent(1)
+
+    assert_equal [Arc[1,2]], @single.adjacent(1, :type=>:edges)
+    assert_equal [Arc[1,2]], @single.adjacent(1, :type=>:edges, :direction=> :out)
+    assert_equal [Arc[1,2]], @single.adjacent(2, :type=>:edges, :direction=> :in)
+    assert_equal [Arc[1,2],Arc[2,3]], @single.adjacent(2, :type=>:edges, :direction=> :all).sort
+
+    [[{},1], [{:direction => :out},1], [{:direction => :in},2]].each do |h,v|
+      adj = @dups.adjacent(v, h.merge(:type=>:edges))
+      assert_equal 2, adj.size
+      adj.each {|e| assert e.source == 1; assert e.target == 2}
+    end 
+    
+    adj = @dups.adjacent(2, {:type=>:edges,:direction=>:all})
+    assert_equal 4, adj.size
+    adj.each do |e| 
+      assert((e.source==1 and e.target==2) ||
+             (e.source==2 and e.target==3)) 
+    end
+    
+    assert_equal [2],   @single.adjacent(1, :type=>:vertices)
+    assert_equal [2],   @single.adjacent(1, :type=>:vertices, :direction=> :out)
+    assert_equal [1],   @single.adjacent(2, :type=>:vertices, :direction=> :in)
+    assert_equal [1,3], @single.adjacent(2, :type=>:vertices, :direction=> :all)
+
+    assert_equal [3], @single.adjacent(Arc[2,3], :type=>:vertices)
+    assert_equal [3], @single.adjacent(Arc[2,3], :type=>:vertices, :direction=> :out)
+    assert_equal [2], @single.adjacent(Arc[2,3], :type=>:vertices, :direction=> :in)
+    assert_equal [2,3], @single.adjacent(Arc[2,3], :type=>:vertices, :direction=> :all)
+
+    assert_equal [Arc[3,4]], @single.adjacent(Arc[2,3], :type=>:edges)
+    assert_equal [Arc[3,4]], @single.adjacent(Arc[2,3], :type=>:edges, :direction=> :out)
+    assert_equal [Arc[1,2]], @single.adjacent(Arc[2,3], :type=>:edges, :direction=> :in)
+    assert_equal [Arc[1,2],Arc[3,4]], @single.adjacent(Arc[2,3], :type=>:edges, :direction=> :all).sort
+    
+    assert_equal [MultiArc[3,4]], @dups.adjacent(MultiArc[2,3], :type=>:edges)
+    assert_equal [MultiArc[3,4]], @dups.adjacent(MultiArc[2,3], :type=>:edges, :direction=> :out)
+    assert_equal [MultiArc[1,2]]*2, @dups.adjacent(MultiArc[2,3], :type=>:edges, :direction=> :in)
+    assert_equal ([MultiArc[1,2]]*2+[MultiArc[3,4]]), @dups.adjacent(MultiArc[2,3], :type=>:edges, :direction=> :all).sort
+  end
+
+  def test_neighborhood
+    assert_equal [2],    @single.neighborhood(1).sort
+    assert_equal [1,3],  @single.neighborhood(2).sort
+    assert_equal [Arc[1,2], Arc[3,4]], @single.neighborhood(Arc[2,3]).sort
+  end
+
+  def test_degree
+    assert_equal 0, @single.in_degree(1)
+    assert_equal 1, @single.in_degree(2)
+    assert_equal 1, @single.in_degree(4)
+    assert_equal 3, @loops.degree(4)
+    assert_equal 2, @loops.in_degree(4)
+    assert_equal 1, @single.out_degree(1)
+    assert_equal 1, @single.out_degree(2)
+    assert_equal 0, @single.out_degree(4)
+    assert_equal 1, @loops.out_degree(4)
+    assert_equal 0, @single.add_vertex!(6).out_degree(6)
+    assert_equal 0, @single.add_vertex!(7).in_degree(7)
+    assert_equal 1, @single.add_edge!(4,2).out_degree(4)
+    assert_equal 2, @loops.add_edge!(4,2).out_degree(4)
+    assert_equal 2, @single.in_degree(2)
+
+    assert_equal 0, @single.min_in_degree
+    assert_equal 2, @single.max_in_degree
+    assert_equal 0, @single.min_out_degree
+    assert_equal 1, @single.max_out_degree
+
+    assert_equal 0, @loops.min_in_degree
+    assert_equal 2, @loops.max_in_degree
+    assert_equal 1, @loops.min_out_degree
+    assert_equal 2, @loops.max_out_degree
+    assert_equal 4, @loops.degree(2)
+    assert_equal 1, @single.degree(1)
+    assert !@loops.regular?
+    assert !@single.regular?
+    assert !@dups.regular?
+  end
+
+  def test_include
+    assert @single.include?(2)
+    assert !@single.include?(23)
+    assert @single.include?(Arc[1,2])
+    assert !@single.include?(Arc[1,4])
+  end
+
+end

data/tests/TestDigraphDistance.rb

@@ -0,0 +1,138 @@
+#--
+# 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 'test/unit'
+require 'gratr/import'
+
+class TestDigraphDistance < Test::Unit::TestCase # :nodoc:
+
+  def setup  
+    @d = Digraph[ :a,:b, :a,:e,
+                  :b,:c, :b,:e,
+                  :c,:d,
+                  :d,:c,
+                  :e,:b, :e,:f,
+                  :f,:c, :f,:d, :f,:e ]
+  
+    @w = {  Arc[:a,:b] => 9,
+            Arc[:a,:e] => 3,
+            Arc[:b,:c] => 2,
+            Arc[:b,:e] => 6,
+            Arc[:c,:d] => 1,
+            Arc[:d,:c] => 2,
+            Arc[:e,:b] => 2,
+            Arc[:e,:f] => 1,
+            Arc[:f,:c] => 2,
+            Arc[:f,:d] => 7,
+            Arc[:f,:e] => 2  }
+    @a = {  :a => 0,
+            :b => 5,
+            :c => 6,
+            :d => 7,
+            :e => 3,
+            :f => 4   }
+    @simple_weight = Proc.new {|e| 1}            
+  end
+  
+  def test_shortest_path
+    x = Digraph[ :s,:u, :s,:w,
+                 :j,:v,
+                 :u,:j,
+                 :v,:y,
+                 :w,:u, :w,:v, :w,:y, :w,:x,
+                 :x,:z ]
+    assert x.acyclic?
+    cost, path = x.shortest_path(:s,@simple_weight)
+    assert_equal({:x=>2, :v=>2, :y=>2, :w=>1, :s=>0, :z=>3, :u=>1, :j=> 2}, cost)
+    assert_equal({:x=>:w, :v=>:w, :y=>:w, :w=>:s, :z=>:x, :u=>:s, :j=>:u},  path)
+  end
+  
+  def test_dijkstra_with_proc
+    p = Proc.new {|e| @w[e]}
+    distance, path = @d.dijkstras_algorithm(:a,p)
+    assert_equal @a, distance
+    assert_equal({ :d => :c,  :c => :f,  :f => :e,  :b => :e,  :e => :a}, path)
+  end
+  
+  def test_dijkstra_with_label
+    @w.keys.each {|e| @d[e] = @w[e]}
+    assert_equal @a, @d.dijkstras_algorithm(:a)[0]
+  end
+
+  def test_dijkstra_with_bracket_label
+    @w.keys.each do |e|
+      @d[e] = { :xyz => (@w[e])} 
+    end
+    assert_equal @a, @d.dijkstras_algorithm(:a, :xyz)[0]
+    @w.keys.each do |e|
+      @d[e] = [@w[e]] 
+    end
+    assert_equal @a, @d.dijkstras_algorithm(:a, 0)[0]
+  end
+  
+  def test_floyd_warshall
+    simple = Digraph[ 0,1,  0,2,  1,2,  1,3,  2,3,  3,0 ]
+    
+    cost, path, delta = simple.floyd_warshall(@simple_weight)
+    # Costs
+    assert_equal({0=>3, 1=>1, 2=>1, 3=>2}, cost[0])
+    assert_equal({0=>2, 1=>3, 2=>1, 3=>1}, cost[1])
+    assert_equal({0=>2, 1=>3, 2=>3, 3=>1}, cost[2])
+    assert_equal({0=>1, 1=>2, 2=>2, 3=>3}, cost[3])
+    
+    # Paths
+    assert_equal({0=>1, 1=>1, 2=>2, 3=>1}, path[0])
+    assert_equal({0=>3, 1=>3, 2=>2, 3=>3}, path[1])
+    assert_equal({0=>3, 1=>3, 2=>3, 3=>3}, path[2])
+    assert_equal({0=>0, 1=>0, 2=>0, 3=>0}, path[3])
+    
+    # Deltas
+    assert_equal 1,  delta[0]
+    assert_equal 1,  delta[1]
+    assert_equal -1, delta[2]
+    assert_equal -1, delta[3]
+  end
+  
+  def test_bellman_ford_moore
+    fig24 = Digraph[ [:s,:e] =>  8,
+                     [:s,:d] =>  4,
+                     [:e,:c] =>  2,
+                     [:e,:d] => -5,
+                     [:c,:b] => -2,
+                     [:d,:c] => -2,
+                     [:d,:a] =>  4,
+                     [:a,:c] => 10,
+                     [:a,:b] =>  9,
+                     [:b,:c] =>  5,
+                     [:b,:a] => -3]
+    cost, path = fig24.bellman_ford_moore(:s)
+    assert_equal({:e=>8, :d=>3, :c=>1, :b=>-1, :a=>-4, :s=>0}, cost)
+    assert_equal({:e=>:s, :d=>:e, :c=>:d, :b=>:c, :a=>:b},     path)
+  end
+  
+end