rgl 0.4.0 → 0.5.0

data/{tests → test}/test_helper.rb

@@ -1,7 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+
 # Some helper utilities used in test classes
 
 class Array
   # We need Array#add in test classes to be able to use Arrays as adjacency lists
-  # This is needed to have ordered lists as neigbors in our test graphs.
+  # This is needed to have ordered lists as neighbors in our test graphs.
   alias add push
 end

data/{tests/TestTransitivity.rb → test/transitivity_test.rb}

@@ -1,27 +1,27 @@
-require 'test/unit'
-require 'rgl/transitivity'
 require 'test_helper'
 
+require 'rgl/transitivity'
+
 include RGL
 
 class TestTransitiveClosure < Test::Unit::TestCase
 
   def setup
     @dg = DirectedAdjacencyGraph.new
-    @dg.add_edges([1,2],[2,3],[2,4],[4,5],[1,6],[6,4])
+    @dg.add_edges([1, 2], [2, 3], [2, 4], [4, 5], [1, 6], [6, 4])
     @dg_tc = DirectedAdjacencyGraph.new
     @dg_tc.add_edges(
-      [1,2],[1,3],[1,4],[1,5],[1,6],
-      [2,3],[2,4],[2,5],
-      [4,5],
-      [6,4],[6,5]
+        [1, 2], [1, 3], [1, 4], [1, 5], [1, 6],
+        [2, 3], [2, 4], [2, 5],
+        [4, 5],
+        [6, 4], [6, 5]
     )
     @dg_tr = DirectedAdjacencyGraph.new
     @dg_tr.add_edges(
-      [1,2],[1,6],
-      [2,3],[2,4],
-      [4,5],
-      [6,4]
+        [1, 2], [1, 6],
+        [2, 3], [2, 4],
+        [4, 5],
+        [6, 4]
     )
 
     @dg_loner = @dg.dup
@@ -33,30 +33,30 @@ class TestTransitiveClosure < Test::Unit::TestCase
 
     @dg_cyclic = DirectedAdjacencyGraph.new
     @dg_cyclic.add_edges(
-      [1,1],[1,2],
-      [2,3],
-      [3,4],
-      [4,5],
-      [5,6],
-      [6,3]
+        [1, 1], [1, 2],
+        [2, 3],
+        [3, 4],
+        [4, 5],
+        [5, 6],
+        [6, 3]
     )
     @dg_cyclic_tc = DirectedAdjacencyGraph.new
     @dg_cyclic_tc.add_edges(
-      [1,1],[1,2],[1,3],[1,4],[1,5],[1,6],
-      [2,3],[2,4],[2,5],[2,6],
-      [3,3],[3,4],[3,5],[3,6],
-      [4,3],[4,4],[4,5],[4,6],
-      [5,3],[5,4],[5,5],[5,6],
-      [6,3],[6,4],[6,5],[6,6]
+        [1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6],
+        [2, 3], [2, 4], [2, 5], [2, 6],
+        [3, 3], [3, 4], [3, 5], [3, 6],
+        [4, 3], [4, 4], [4, 5], [4, 6],
+        [5, 3], [5, 4], [5, 5], [5, 6],
+        [6, 3], [6, 4], [6, 5], [6, 6]
     )
     @dg_cyclic_tr = DirectedAdjacencyGraph.new
     @dg_cyclic_tr.add_edges(
-      [1,1],[1,2],
-      [2,3],
-      [3,4],
-      [4,5],
-      [5,6],
-      [6,3]
+        [1, 1], [1, 2],
+        [2, 3],
+        [3, 4],
+        [4, 5],
+        [5, 6],
+        [6, 3]
     )
   end
 
@@ -67,8 +67,8 @@ class TestTransitiveClosure < Test::Unit::TestCase
     # Iterative applications of transitive closure should return the same result
     # as a single application.
     assert_equal(
-      @dg.transitive_closure,
-      @dg.transitive_closure.transitive_closure
+        @dg.transitive_closure,
+        @dg.transitive_closure.transitive_closure
     )
 
     # Compute for a graph containing vertices without edges.
@@ -77,8 +77,8 @@ class TestTransitiveClosure < Test::Unit::TestCase
     # Iterative applications of transitive closure should return the same result
     # as a single application.
     assert_equal(
-      @dg_loner.transitive_closure,
-      @dg_loner.transitive_closure.transitive_closure
+        @dg_loner.transitive_closure,
+        @dg_loner.transitive_closure.transitive_closure
     )
 
     # Compute for a graph with cycles.
@@ -87,13 +87,13 @@ class TestTransitiveClosure < Test::Unit::TestCase
     # Iterative applications of transitive closure should return the same result
     # as a single application.
     assert_equal(
-      @dg_cyclic.transitive_closure,
-      @dg_cyclic.transitive_closure.transitive_closure
+        @dg_cyclic.transitive_closure,
+        @dg_cyclic.transitive_closure.transitive_closure
     )
   end
 
   def test_transitive_closure_undirected
-    assert_raises(NotDirectedError) {AdjacencyGraph.new.transitive_closure}
+    assert_raises(NotDirectedError) { AdjacencyGraph.new.transitive_closure }
   end
 
   def test_transitive_reduction
@@ -109,21 +109,21 @@ class TestTransitiveClosure < Test::Unit::TestCase
     # Test that the transitive closure of a transitive reduction is the same as
     # the transitive closure of the original graph.
     assert_equal(
-      @dg.transitive_closure,
-      @dg.transitive_reduction.transitive_closure
+        @dg.transitive_closure,
+        @dg.transitive_reduction.transitive_closure
     )
     assert_equal(
-      @dg_loner.transitive_closure,
-      @dg_loner.transitive_reduction.transitive_closure
+        @dg_loner.transitive_closure,
+        @dg_loner.transitive_reduction.transitive_closure
     )
     assert_equal(
-      @dg_cyclic.transitive_closure,
-      @dg_cyclic.transitive_reduction.transitive_closure
+        @dg_cyclic.transitive_closure,
+        @dg_cyclic.transitive_reduction.transitive_closure
     )
   end
 
   def test_transitive_reduction_undirected
-    assert_raises(NotDirectedError) {AdjacencyGraph.new.transitive_reduction}
+    assert_raises(NotDirectedError) { AdjacencyGraph.new.transitive_reduction }
   end
 end
 

data/test/traversal_test.rb

@@ -0,0 +1,221 @@
+require 'test_helper'
+
+require 'rgl/adjacency'
+require 'rgl/traversal'
+require 'rgl/topsort'
+require 'rgl/implicit'
+
+include RGL
+
+class TestTraversal < Test::Unit::TestCase
+
+  def setup
+    @dg   = DirectedAdjacencyGraph.new(Array)
+    edges = [[1, 2], [2, 3], [2, 4], [4, 5], [1, 6], [6, 4]]
+    edges.each do |(src, target)|
+      @dg.add_edge(src, target)
+    end
+    @bfs = @dg.bfs_iterator(1)
+    @dfs = @dg.dfs_iterator(1)
+
+    @ug = AdjacencyGraph.new(Array)
+    @ug.add_edges(*edges)
+  end
+
+  def test_bfs_iterator_creation
+    assert(@bfs.at_beginning?)
+    assert(!@bfs.at_end?)
+    assert_equal(1, @bfs.start_vertex)
+    assert_equal(@dg, @bfs.graph)
+  end
+
+  def test_bfs_visiting
+    expected = [1, 2, 6, 3, 4, 5]
+    assert_equal(expected, @bfs.to_a)
+    assert_equal(expected, @ug.bfs_iterator(1).to_a)
+    assert_equal([2, 1, 3, 4, 6, 5], @ug.bfs_iterator(2).to_a)
+  end
+
+  def test_bfs_event_handlers
+    expected = <<END
+tree_edge      : -1
+examine_vertex : 1
+examine_edge   : 1-2
+tree_edge      : 1-2
+examine_edge   : 1-6
+tree_edge      : 1-6
+finished_vertex: 1
+examine_vertex : 2
+examine_edge   : 2-3
+tree_edge      : 2-3
+examine_edge   : 2-4
+tree_edge      : 2-4
+finished_vertex: 2
+examine_vertex : 6
+examine_edge   : 6-4
+back_edge      : 6-4
+finished_vertex: 6
+examine_vertex : 3
+finished_vertex: 3
+examine_vertex : 4
+examine_edge   : 4-5
+tree_edge      : 4-5
+finished_vertex: 4
+examine_vertex : 5
+examine_edge   : 5-3
+forward_edge   : 5-3
+finished_vertex: 5
+END
+
+    s = ''
+    @dg.add_edge 5, 3 # for the forward_edge 5-3
+    @bfs.set_examine_vertex_event_handler  { |v| s << "examine_vertex : #{v}\n" }
+    @bfs.set_examine_edge_event_handler { |u, v| s << "examine_edge   : #{u}-#{v}\n" }
+    @bfs.set_tree_edge_event_handler    { |u, v| s << "tree_edge      : #{u}-#{v}\n" }
+    @bfs.set_back_edge_event_handler    { |u, v| s << "back_edge      : #{u}-#{v}\n" }
+    @bfs.set_forward_edge_event_handler { |u, v| s << "forward_edge   : #{u}-#{v}\n" }
+
+    @bfs.each { |v| s << "finished_vertex: #{v}\n" }
+    puts "BFS: ", s if $DEBUG
+    assert_equal(expected, s)
+  end
+
+  def test_dfs_visiting
+    assert_equal([1, 6, 4, 5, 2, 3], @dg.dfs_iterator(1).to_a)
+    assert_equal([2, 4, 5, 3], @dg.dfs_iterator(2).to_a)
+  end
+
+  def test_dfs_event_handlers
+    expected = <<END
+tree_edge      : -1
+examine_vertex : 1
+examine_edge   : 1-2
+tree_edge      : 1-2
+examine_edge   : 1-6
+tree_edge      : 1-6
+finished_vertex: 1
+examine_vertex : 6
+examine_edge   : 6-4
+tree_edge      : 6-4
+finished_vertex: 6
+examine_vertex : 4
+examine_edge   : 4-5
+tree_edge      : 4-5
+finished_vertex: 4
+examine_vertex : 5
+examine_edge   : 5-3
+tree_edge      : 5-3
+finished_vertex: 5
+examine_vertex : 3
+finished_vertex: 3
+examine_vertex : 2
+examine_edge   : 2-3
+forward_edge   : 2-3
+examine_edge   : 2-4
+forward_edge   : 2-4
+finished_vertex: 2
+END
+
+    s        = ''
+    @dg.add_edge 5, 3
+    @dfs.set_examine_vertex_event_handler  { |v| s << "examine_vertex : #{v}\n" }
+    @dfs.set_examine_edge_event_handler { |u, v| s << "examine_edge   : #{u}-#{v}\n" }
+    @dfs.set_tree_edge_event_handler    { |u, v| s << "tree_edge      : #{u}-#{v}\n" }
+    @dfs.set_back_edge_event_handler    { |u, v| s << "back_edge      : #{u}-#{v}\n" }
+    @dfs.set_forward_edge_event_handler { |u, v| s << "forward_edge   : #{u}-#{v}\n" }
+
+    @dfs.each { |v| s << "finished_vertex: #{v}\n" }
+    puts "DFS: ", s if $DEBUG
+    assert_equal(expected, s)
+  end
+
+  def test_bfs_search_tree
+    assert_equal("(1-2)(1-6)(2-3)(2-4)(4-5)", @dg.bfs_search_tree_from(1).edges.sort.join)
+  end
+
+  def aux(it)
+    it.attach_distance_map
+    it.set_to_end
+    it.graph.vertices.sort.collect { |v|
+      "#{v}-#{it.distance_to_root(v)}"
+    }.join(', ')
+  end
+
+  def test_distance_map
+    assert_equal("1-0, 2-1, 3-2, 4-2, 5-3, 6-1", aux(@bfs))
+    @dg.add_edge 5, 3
+    assert_equal("1-0, 2-1, 3-4, 4-2, 5-3, 6-1", aux(@dfs))
+  end
+
+  def test_topsort
+    ts_it = @dg.topsort_iterator
+    assert(ts_it.at_beginning?)
+    assert_equal(@dg, ts_it.graph)
+    assert(!ts_it.at_end?)
+    ts_order = ts_it.to_a # do the traversal
+    assert_equal(@dg.num_vertices, ts_order.size)
+
+    # Check topsort contraint:
+    @dg.each_edge { |u, v|
+      assert(ts_order.index(u) < ts_order.index(v))
+    }
+    ts_it.set_to_begin
+    assert(ts_it.at_beginning?)
+
+    # Topsort on undirected graphs is empty
+    assert(@ug.topsort_iterator.at_end?)
+  end
+
+  # depth_first_search can also be used to compute a topsort!
+  def test_dfs_search_as_topsort
+    ts_order = []
+    @dg.depth_first_search { |v| ts_order << v }
+    ts_order = ts_order.reverse
+    @dg.each_edge { |u, v|
+      assert(ts_order.index(u) < ts_order.index(v))
+    }
+  end
+
+  def test_acyclic
+    assert(@dg.acyclic?)
+    @dg.add_edge 5, 2 # add cycle
+    assert(!@dg.acyclic?)
+  end
+
+  def test_dfs_visit
+    a = []
+    @dg.depth_first_visit(1) { |x| a << x }
+    assert_equal([3, 5, 4, 2, 6, 1], a)
+
+    a = []
+    @dg.add_edge 10, 11
+    @dg.depth_first_visit(10) { |x| a << x }
+    assert_equal([11, 10], a)
+  end
+
+  def test_dfs_visit_with_parens
+    a = ""
+    vis = DFSVisitor.new(@dg)
+    vis.set_examine_vertex_event_handler { |v| a << "(#{v} " }
+    vis.set_finish_vertex_event_handler  { |v| a << " #{v})" }
+    @dg.depth_first_visit(1, vis) { |x| }
+    assert_equal("(1 (2 (3  3)(4 (5  5) 4) 2)(6  6) 1)", a)
+  end
+
+  def test_depth_first_search_with_parens
+    @dg.add_edge 10, 11
+    # We must ensure, that the order of the traversal is not dependend on the
+    # order of the each iterator in the hash map of the adjacency graph. Therefor we
+    # wrap the graph with an implicit graph that simply ensures a sort order on
+    # the vertices.
+    dg  = @dg.implicit_graph { |g|
+      g.vertex_iterator { |b| @dg.vertices.sort.each(&b) }
+    }
+    a = ""
+    vis = DFSVisitor.new(dg)
+    vis.set_examine_vertex_event_handler { |v| a << "(#{v} " }
+    vis.set_finish_vertex_event_handler  { |v| a << " #{v})" }
+    dg.depth_first_search(vis) { |x| }
+    assert_equal("(1 (2 (3  3)(4 (5  5) 4) 2)(6  6) 1)(10 (11  11) 10)", a)
+  end
+end

data/test/undirected_graph_test.rb

@@ -0,0 +1,103 @@
+require 'test_helper'
+
+require 'rgl/adjacency'
+
+include RGL
+include RGL::Edge
+
+class TestUnDirectedGraph < Test::Unit::TestCase
+
+  def setup
+    @dg = AdjacencyGraph.new
+    [[1, 2], [2, 3], [3, 2], [2, 4]].each do |(src, target)|
+      @dg.add_edge(src, target)
+    end
+  end
+
+  def test_empty_graph
+    dg = AdjacencyGraph.new
+    assert(dg.empty?)
+    assert(!dg.directed?)
+    assert(!dg.has_edge?(2, 1))
+    assert(!dg.has_vertex?(3))
+    # Non existent vertex result in a Name Error because each_key is
+    # called for nil
+    assert_raises(NoVertexError) { dg.out_degree(3) }
+    assert_equal([], dg.vertices)
+    assert_equal(0, dg.size)
+    assert_equal(0, dg.num_vertices)
+    assert_equal(0, dg.num_edges)
+    assert_equal(UnDirectedEdge, dg.edge_class)
+    assert([].eql?(dg.edges))
+    assert([].eql?(dg.to_a))
+  end
+
+  def test_add
+    dg = AdjacencyGraph.new
+    dg.add_edge(1, 2)
+    assert(!dg.empty?)
+    assert(dg.has_edge?(1, 2))
+    assert(dg.has_edge?(2, 1), "Backwards edge not included!")
+    assert(dg.has_vertex?(1) && dg.has_vertex?(2))
+    assert(!dg.has_vertex?(3))
+
+    assert_equal([1, 2], dg.vertices.sort)
+    assert([DirectedEdge.new(1, 2)].eql?(dg.edges))
+    assert_equal("(1=2)", dg.edges.join)
+
+    assert_equal([2], dg.adjacent_vertices(1))
+    assert_equal([1], dg.adjacent_vertices(2))
+
+    assert_equal(1, dg.out_degree(1))
+    assert_equal(1, dg.out_degree(2))
+  end
+
+  def test_edges
+    assert_equal(3, @dg.edges.length)
+    edges = [[1, 2], [2, 3], [2, 4]].map { |x| UnDirectedEdge.new(*x) }
+    assert_equal(edges, @dg.edges.sort)
+#    assert_equal([0,1,2,3], @dg.edges.map {|l| l.info}.sort)
+  end
+
+  def test_vertices
+    assert_equal([1, 2, 3, 4], @dg.vertices.sort)
+  end
+
+  def test_edges_from_to?
+    assert @dg.has_edge?(1, 2)
+    assert @dg.has_edge?(2, 3)
+    assert @dg.has_edge?(3, 2)
+    assert @dg.has_edge?(2, 4)
+    assert @dg.has_edge?(2, 1)
+    assert !@dg.has_edge?(3, 1)
+    assert !@dg.has_edge?(4, 1)
+    assert @dg.has_edge?(4, 2)
+  end
+
+  def test_remove_edges
+    @dg.remove_edge 1, 2
+    assert !@dg.has_edge?(1, 2), "(1,2) should not be an edge any more."
+    @dg.remove_edge 1, 2
+    assert !@dg.has_edge?(2, 1)
+    @dg.remove_vertex 3
+    assert !@dg.has_vertex?(3), "3 should not be a vertex any more."
+    assert !@dg.has_edge?(2, 3)
+    assert_equal([UnDirectedEdge.new(2, 4)], @dg.edges)
+  end
+
+  def test_add_vertices
+    dg = AdjacencyGraph.new
+    dg.add_vertices 1, 3, 2, 4
+    assert_equal dg.vertices.sort, [1, 2, 3, 4]
+
+    dg.remove_vertices 1, 3
+    assert_equal dg.vertices.sort, [2, 4]
+
+    dg.remove_vertices 1, 3, Object # ones again
+    assert_equal dg.vertices.sort, [2, 4]
+  end
+
+  def test_reverse
+    assert_equal(@dg, @dg.reverse)
+  end
+end