laser 0.7.0.pre1

data/test/third_party_tests/rgl_tests/TestTransitivity.rb

@@ -0,0 +1,129 @@
+require 'test/unit'
+require 'laser/third_party/rgl/transitivity'
+require_relative 'test_helper'
+
+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_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]
+    )
+    @dg_tr = DirectedAdjacencyGraph.new
+    @dg_tr.add_edges(
+      [1,2],[1,6],
+      [2,3],[2,4],
+      [4,5],
+      [6,4]
+    )
+
+    @dg_loner = @dg.dup
+    @dg_loner.add_vertices(7, 8, 9)
+    @dg_loner_tc = @dg_tc.dup
+    @dg_loner_tc.add_vertices(7, 8, 9)
+    @dg_loner_tr = @dg_tr.dup
+    @dg_loner_tr.add_vertices(7, 8, 9)
+
+    @dg_cyclic = DirectedAdjacencyGraph.new
+    @dg_cyclic.add_edges(
+      [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]
+    )
+    @dg_cyclic_tr = DirectedAdjacencyGraph.new
+    @dg_cyclic_tr.add_edges(
+      [1,1],[1,2],
+      [2,3],
+      [3,4],
+      [4,5],
+      [5,6],
+      [6,3]
+    )
+  end
+
+  def test_transitive_closure
+    # A simple graph without cycles.
+    assert_equal(@dg_tc, @dg.transitive_closure)
+
+    # Iterative applications of transitive closure should return the same result
+    # as a single application.
+    assert_equal(
+      @dg.transitive_closure,
+      @dg.transitive_closure.transitive_closure
+    )
+
+    # Compute for a graph containing vertices without edges.
+    assert_equal(@dg_loner_tc, @dg_loner.transitive_closure)
+
+    # 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
+    )
+
+    # Compute for a graph with cycles.
+    assert_equal(@dg_cyclic_tc, @dg_cyclic.transitive_closure)
+
+    # 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
+    )
+  end
+
+  def test_transitive_closure_undirected
+    assert_raises(NotDirectedError) {AdjacencyGraph.new.transitive_closure}
+  end
+
+  def test_transitive_reduction
+    # A simple graph without cycles.
+    assert_equal(@dg_tr, @dg.transitive_reduction)
+
+    # Compute for a graph containing vertices without edges.
+    assert_equal(@dg_loner_tr, @dg_loner.transitive_reduction)
+
+    # Compute for a graph with cycles.
+    assert_equal(@dg_cyclic_tr, @dg_cyclic.transitive_reduction)
+
+    # 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
+    )
+    assert_equal(
+      @dg_loner.transitive_closure,
+      @dg_loner.transitive_reduction.transitive_closure
+    )
+    assert_equal(
+      @dg_cyclic.transitive_closure,
+      @dg_cyclic.transitive_reduction.transitive_closure
+    )
+  end
+
+  def test_transitive_reduction_undirected
+    assert_raises(NotDirectedError) {AdjacencyGraph.new.transitive_reduction}
+  end
+end
+

data/test/third_party_tests/rgl_tests/TestTraversal.rb

@@ -0,0 +1,220 @@
+require 'test/unit'
+require 'laser/third_party/rgl/adjacency'
+require 'laser/third_party/rgl/traversal'
+require 'laser/third_party/rgl/topsort'
+require 'laser/third_party/rgl/implicit'
+
+require_relative 'test_helper'
+
+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 = 
+'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
+'
+	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 = 
+'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
+'
+	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/third_party_tests/rgl_tests/TestUnDirectedGraph.rb

@@ -0,0 +1,102 @@
+require 'test/unit'
+require 'laser/third_party/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 existend 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.count)
+	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