rgl 0.4.0 → 0.5.0

data/tests/TestComponents.rb

@@ -1,65 +0,0 @@
-require 'test/unit'
-
-require 'rgl/traversal'
-require 'rgl/connected_components'
-require 'rgl/adjacency'
-require 'test_helper'
-
-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/TestCycles.rb

@@ -1,61 +0,0 @@
-$LOAD_PATH << "../lib"
-require 'test/unit'
-require 'rgl/adjacency'
-require 'test_helper'
-
-include RGL
-
-class TestCycles < Test::Unit::TestCase
-
-  def setup
-    @dg = DirectedAdjacencyGraph.new(Array)
-    edges = [[1,2],[2,2],[2,3],[3,4],[4,5],[5,1],[6,4],[6,6],[1,4],[7,7],[7,7]]
-    edges.each do |(src,target)| 
-      @dg.add_edge(src, target)
-    end
-
-    @ug = AdjacencyGraph.new(Array)
-    @ug.add_edges(*edges)
-  end
-
-  # Helper for testing for different permutations of a cycle
-  def contains_cycle?(cycles,cycle)
-    cycle.size.times do |i|
-      return true if cycles.include?(cycle)
-      cycle = cycle[1..-1] + [cycle[0]]
-    end
-  end
-
-  def test_cycles
-    d_cycles = @dg.cycles
-    assert_equal 6, d_cycles.size
-    assert d_cycles.include?([6])
-    assert d_cycles.include?([7])
-    assert d_cycles.include?([2])
-    assert contains_cycle?(d_cycles, [1,4,5])
-    assert contains_cycle?(d_cycles, [1,2,3,4,5])
-  
-    assert_equal 5, DirectedAdjacencyGraph.new(Set, @dg).cycles.size
-
-    u_cycles = AdjacencyGraph.new(Set, @dg).cycles.sort
-
-    assert u_cycles.include?([2])
-    assert u_cycles.include?([6])
-    assert u_cycles.include?([7])
-    assert contains_cycle?(u_cycles, [1,2,3,4,5])
-    assert contains_cycle?(u_cycles, [1,5,4,3,2])
-    assert contains_cycle?(u_cycles, [1,4,3,2])
-    assert contains_cycle?(u_cycles, [1,4,5])
-    assert contains_cycle?(u_cycles, [1,5,4])
-    assert contains_cycle?(u_cycles, [1,5])
-    assert contains_cycle?(u_cycles, [1,2])
-    assert contains_cycle?(u_cycles, [1,2,3,4])
-    assert contains_cycle?(u_cycles, [2,3])
-    assert contains_cycle?(u_cycles, [1,4])
-    assert contains_cycle?(u_cycles, [3,4])
-    assert contains_cycle?(u_cycles, [4,5])
-    assert contains_cycle?(u_cycles, [4,6])
-    assert_equal 16, u_cycles.size
-  end
-
-end

data/tests/TestDirectedGraph.rb

@@ -1,125 +0,0 @@
-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
-  
-  def test_reverse
-    reverted = @dg.reverse
-    @dg.each_edge do |u,v|
-      assert(reverted.has_edge?(v,u))
-    end
-  end
-  
-  def test_reverse
-    # Add isolated vertex
-    @dg.add_vertex(42)
-    reverted = @dg.reverse
-    
-    @dg.each_edge do |u,v|
-      assert(reverted.has_edge?(v,u))
-    end
-    
-    assert(reverted.has_vertex?(42),
-           "Reverted graph should contain isolated Vertex 42")
-  end
-  
-  def test_to_undirected
-    undirected = @dg.to_undirected
-    assert_equal undirected.edges.sort.to_s, "(1=2)(2=3)(2=4)"
-  end
-end

data/tests/TestDot.rb

@@ -1,18 +0,0 @@
-require 'test/unit'
-require 'rgl/dot'
-
-class TestDot < Test::Unit::TestCase
-
-  def test_to_dot_graph
-    graph = RGL::DirectedAdjacencyGraph[1,2]
-    dot = graph.to_dot_graph.to_s
-    assert_match(dot, /\{[^}]*\}/) # {...}
-    assert_match(dot, /1\s*\[/) # node 1
-    assert_match(dot, /2\s*\[/) # node 2
-    assert_match(dot, /1\s*->\s*2/) # edge
-  end
-
-  def assert_match(dot, pattern)
-    assert(!(dot =~ pattern).nil?, "#{dot} doesn't match #{pattern}")
-  end
-end

data/tests/TestEdge.rb

@@ -1,34 +0,0 @@
-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("(2-1)",e.reverse.to_s)
-    assert_equal([1,2],[e[0],e[1]])
-    assert(DirectedEdge[1,2].eql?(DirectedEdge.new(1,2)))
-    assert(!DirectedEdge[1,2].eql?(DirectedEdge.new(1,3)))
-    assert(!DirectedEdge[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

@@ -1,57 +0,0 @@
-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.new.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).new.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

@@ -1,52 +0,0 @@
-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/TestTraversal.rb

@@ -1,220 +0,0 @@
-require 'test/unit'
-require 'rgl/adjacency'
-require 'rgl/traversal'
-require 'rgl/topsort'
-require 'rgl/implicit'
-
-require '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.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