rgl 0.2.2

data/tests/TestComponents.rb

@@ -0,0 +1,67 @@
+require 'test/unit'
+
+require 'rgl/connected_components'
+require 'rgl/adjacency'
+
+class Array
+  alias add push
+end
+
+include RGL
+
+def graph_from_string(s)
+  g = DirectedAdjacencyGraph.new(Array)
+  s.split(/\n/).collect{|x| x.split(/->/)}.each do |a|
+	from = a[0].strip
+	a[1].split.each do |to|
+	  g.add_edge from,to
+	end
+  end
+  g
+end
+
+class TestComponents < 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)
+
+	@dg2 = graph_from_string(
+"a -> b f h 
+b -> c a 
+c -> d b 
+d -> e 
+e -> d 
+f -> g 
+g -> f d 
+h -> i 
+i -> h j e c")
+  end
+
+  def test_connected_components
+	ccs = []
+	@ug.each_connected_component { |c| ccs << c }
+	assert_equal(1,ccs.size)
+
+	ccs = []
+	@ug.add_edge 10,11
+	@ug.add_edge 33,44
+	@ug.each_connected_component { |c| ccs << c.sort }
+	assert_equal([[10, 11], [1, 2, 3, 4, 5, 6], [33,44]].sort,ccs.sort)
+  end
+
+  def test_strong_components
+	vis = @dg2.strongly_connected_components
+	
+	assert_equal(4,vis.num_comp)
+	assert_equal([["a", 3], ["b", 3], ["c", 3], ["d", 0], ["e", 0], ["f", 1], ["g", 1], ["h", 3], ["i", 3], ["j", 2]],vis.comp_map.to_a)
+  end
+end

data/tests/TestDirectedGraph.rb

@@ -0,0 +1,100 @@
+require 'test/unit'
+require 'rgl/adjacency'
+
+include RGL
+include RGL::Edge
+
+class TestDirectedGraph < Test::Unit::TestCase
+  def setup
+    @dg = DirectedAdjacencyGraph.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 = DirectedAdjacencyGraph.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(DirectedEdge,dg.edge_class)
+	assert([].eql?(dg.edges))
+  end
+
+  def test_add
+	dg = DirectedAdjacencyGraph.new
+	dg.add_edge(1,2)
+	assert(!dg.empty?)
+	assert(dg.has_edge?(1,2))
+	assert(!dg.has_edge?(2,1))
+	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.to_s)
+
+	assert_equal([2],dg.adjacent_vertices(1))
+	assert_equal([],dg.adjacent_vertices(2))
+
+	assert_equal(1,dg.out_degree(1))
+	assert_equal(0,dg.out_degree(2))
+  end
+
+  def test_edges
+    assert_equal(4, @dg.edges.length)
+    assert_equal([1,2,2,3], @dg.edges.map {|l| l.source}.sort)
+    assert_equal([2,2,3,4], @dg.edges.map {|l| l.target}.sort)
+    assert_equal("(1-2)(2-3)(2-4)(3-2)", @dg.edges.map {|l| l.to_s}.sort.join)
+#    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)
+	@dg.remove_edge 1,2
+	assert !@dg.has_edge?(1,2)
+	@dg.remove_vertex 3
+	assert !@dg.has_vertex?(3)
+	assert !@dg.has_edge?(2,3)
+	assert_equal("(2-4)",@dg.to_s)
+  end
+
+  def test_add_vertices
+	dg = DirectedAdjacencyGraph.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]
+  end
+
+  def test_creating_from_array
+	dg = DirectedAdjacencyGraph[1, 2, 3, 4]
+	assert_equal(dg.vertices.sort, [1,2,3,4])
+	assert_equal(dg.edges.to_s, "(1-2)(3-4)")
+  end
+end

data/tests/TestEdge.rb

@@ -0,0 +1,33 @@
+require 'test/unit'
+require 'rgl/base'
+
+include RGL::Edge
+
+class TestEdge < Test::Unit::TestCase
+
+  def test_directed_edge
+	assert_raises(ArgumentError) {DirectedEdge.new}
+	e = DirectedEdge.new 1,2
+	assert_equal(1,e.source)
+	assert_equal(2,e.target)
+	assert_equal([1,2],e.to_a)
+	assert_equal("(1-2)",e.to_s)
+	assert_equal([1,2],[e[0],e[1]])
+	assert(DirectedEdge.new(1,2).eql?(DirectedEdge.new(1,2)))
+	assert(!DirectedEdge.new(1,2).eql?(DirectedEdge.new(1,3)))
+	assert(!DirectedEdge.new(2,1).eql?(DirectedEdge.new(1,2)))
+  end
+
+  def test_undirected_edge
+	assert_raises(ArgumentError) {UnDirectedEdge.new}
+	e = UnDirectedEdge.new 1,2
+	assert_equal(1,e.source)
+	assert_equal(2,e.target)
+	assert_equal([1,2],e.to_a)
+	assert_equal("(1=2)",e.to_s)
+	assert(UnDirectedEdge.new(1,2).eql?(UnDirectedEdge.new(2,1)))
+	assert(!UnDirectedEdge.new(1,3).eql?(UnDirectedEdge.new(2,1)))
+	assert_equal(UnDirectedEdge.new(1,2).hash,UnDirectedEdge.new(1,2).hash)
+  end
+
+end

data/tests/TestGraphXML.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require 'rgl/graphxml'
+require 'rgl/adjacency'
+require 'rgl/topsort'
+require 'rgl/connected_components'
+require 'rgl/dot'
+
+include RGL
+
+class TestGraphXML < Test::Unit::TestCase
+  NORTH_DIR = './examples/north/'
+
+  def setup
+    @stream = File.new(NORTH_DIR + "g.10.0.graphml")
+  end
+
+  def tear_down
+	@stream.close
+  end
+
+  def test_graphxml
+	@dg = DirectedAdjacencyGraph.from_graphxml(@stream).to_s
+	assert_equal("(n0-n1)(n0-n2)(n0-n9)(n3-n4)(n4-n5)(n5-n7)(n8-n0)(n8-n3)(n8-n4)(n8-n5)(n8-n6)",@dg.to_s)
+  end
+
+  def test_north_graphs
+	name,nnodes,nedges = '',0,0
+	IO.foreach(NORTH_DIR + '/Graph.log') {
+	  |line|
+	  if /name:\s*(.*)\sformat: graphml\s+nodes: (\d+)\s+edges: (\d+)/ =~ line
+		name,nnodes,nedges = $1,$2.to_i,$3.to_i
+	  end
+	  if name && /directed: (\w+).*acyclic: (\w+).*connected: (\w+).*biconnected: (\w+)\s+/ =~ line
+		directed, acyclic, connected, biconnected = $1,$2,$3,$4
+		File.open(NORTH_DIR + name + '.graphml') {
+		  |file|
+		  print '.'; $stdout.flush
+		  graph = (directed == 'true' ? DirectedAdjacencyGraph : AdjacencyGraph).from_graphxml(file)
+		  #graph.write_to_graphic_file
+		  assert_equal(nnodes,graph.num_vertices)
+		  assert_equal(nedges,graph.num_edges)
+		  assert_equal(acyclic,graph.acyclic?.to_s)
+
+		  num_comp = 0
+		  graph.to_undirected.each_connected_component {|x| num_comp += 1}
+		  assert_equal(connected,(num_comp == 1).to_s)
+
+# 		  if graph.directed?
+# 			num_comp = graph.strongly_connected_components.num_comp
+# 			#puts num_comp
+# 			assert_equal(biconnected, (num_comp == 1).to_s)
+# 		  end
+		}
+	  end
+	}
+  end
+end

data/tests/TestImplicit.rb

@@ -0,0 +1,52 @@
+require 'test/unit'
+require 'rgl/implicit'
+require 'rgl/adjacency'
+
+include RGL
+
+class TestImplicit < Test::Unit::TestCase
+  def setup
+    @dg = DirectedAdjacencyGraph.new
+    [[1,2],[2,3],[2,4],[4,5],[1,6],[6,4]].each do |(src,target)| 
+      @dg.add_edge(src, target)
+    end
+
+	@cycle = ImplicitGraph.new { |g|
+	  g.vertex_iterator { |b| 0.upto(4,&b) }
+	  g.adjacent_iterator { |x, b| b.call((x+1)%5) }
+	  g.directed = true
+	}
+  end
+
+  def test_empty
+	empty = ImplicitGraph.new
+	assert(empty.empty?)
+	assert_equal([],empty.edges)
+	assert_equal([],empty.vertices)
+  end
+
+  def test_cycle
+	assert(!@cycle.empty?)
+	assert_equal([0, 1, 2, 3, 4],@cycle.vertices.sort)
+	assert_equal("(0-1)(1-2)(2-3)(3-4)(4-0)",@cycle.edges.sort.to_s)
+  end
+  
+  def test_vertex_filtered_graph
+	fg = @cycle.vertices_filtered_by {|v| v%2 == 0}
+	assert_equal([0, 2, 4],fg.vertices.sort)
+	assert_equal("(4-0)",fg.edges.sort.to_s)
+	assert(fg.directed?)
+
+	fg = @dg.vertices_filtered_by {|v| v%2 == 0}
+	assert_equal([2, 4, 6],fg.vertices.sort)
+	assert_equal("(2-4)(6-4)",fg.edges.sort.to_s)
+	assert(fg.directed?)
+  end
+
+  def test_edge_filtered_graph
+	fg = @cycle.edges_filtered_by {|u,v| u+v > 3}
+	assert_equal(@cycle.vertices.sort,fg.vertices.sort)
+	assert_equal("(2-3)(3-4)(4-0)",fg.edges.sort.to_s)
+	assert(fg.directed?)
+  end
+end

data/tests/TestTransitiveClosure.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+require 'rgl/transitiv_closure'
+
+include RGL
+
+class Array
+  alias add push
+end
+
+class TestTransitiveClosure < 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
+  end
+
+  def test_transitive_closure
+	assert_equal("(1-2)(1-3)(1-4)(1-6)(2-3)(2-4)(2-5)(4-5)(6-4)(6-5)",
+				 @dg.transitive_closure.to_s)
+  end
+
+  def test_transitive_closure_undirected
+	assert_raises(NotDirectedError) {AdjacencyGraph.new.transitive_closure}
+  end
+end
+

data/tests/TestTraversal.rb

@@ -0,0 +1,222 @@
+require 'test/unit'
+require 'rgl/adjacency'
+require 'rgl/traversal'
+require 'rgl/topsort'
+require 'rgl/implicit'
+
+class Array
+  alias add push
+end
+
+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.to_s)
+  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