rgl 0.4.0 → 0.5.0

data/test/directed_graph_test.rb

@@ -0,0 +1,118 @@
+require 'test_helper'
+
+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 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(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.join)
+
+    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.edges.join)
+  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([1, 2, 3, 4], dg.vertices.sort)
+    assert_equal('(1-2)(3-4)', dg.edges.join)
+  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 '(1=2)(2=3)(2=4)', undirected.edges.sort.join
+  end
+end

data/test/dot_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+require 'rgl/dot'
+require 'rgl/adjacency'
+
+class TestDot < Test::Unit::TestCase
+
+  def assert_match(dot, pattern)
+    assert(!(dot =~ pattern).nil?, "#{dot} doesn't match #{pattern}")
+  end
+
+  def test_to_dot_digraph
+    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 test_to_dot_graph
+    graph = RGL::AdjacencyGraph[1, 2]
+    dot   = graph.write_to_graphic_file
+  end
+end

data/test/edge_properties_map_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+require 'rgl/edge_properties_map'
+
+include RGL
+
+class TestEdgePropertiesMap < Test::Unit::TestCase
+
+  def setup
+    @edge_properties = {
+        [1, 2] => 1,
+        [2, 3] => 3,
+        [1, 3] => 7
+    }
+
+    @edge_properties_lambda = lambda { |edge| @edge_properties[edge] }
+  end
+
+  def test_directed_graph
+    properties_map = EdgePropertiesMap.new(@edge_properties, true)
+
+    assert_equal(1, properties_map.edge_property(1, 2))
+    assert_equal(3, properties_map.edge_property(2, 3))
+    assert_equal(7, properties_map.edge_property(1, 3))
+
+    assert_raise ArgumentError do
+      properties_map.edge_property(2, 1)
+    end
+  end
+
+  def test_undirected_graph
+    properties_map = EdgePropertiesMap.new(@edge_properties, false)
+
+    assert_equal(1, properties_map.edge_property(1, 2))
+    assert_equal(3, properties_map.edge_property(2, 3))
+    assert_equal(7, properties_map.edge_property(1, 3))
+
+    assert_equal(1, properties_map.edge_property(2, 1))
+    assert_equal(3, properties_map.edge_property(3, 2))
+    assert_equal(7, properties_map.edge_property(3, 1))
+  end
+
+  def test_nil_properties
+    assert_raise ArgumentError do
+      EdgePropertiesMap.new(@edge_properties.merge([1, 4] => nil), false)
+    end
+  end
+
+  def test_non_negative_properties_map
+    assert_raise ArgumentError do
+      NonNegativeEdgePropertiesMap.new(@edge_properties.merge([1, 4] => -2), false)
+    end
+  end
+
+  def test_with_lambda
+    properties_map = EdgePropertiesMap.new(@edge_properties_lambda, true)
+
+    assert_equal(1, properties_map.edge_property(1, 2))
+    assert_equal(3, properties_map.edge_property(2, 3))
+    assert_equal(7, properties_map.edge_property(1, 3))
+  end
+
+end

data/test/edge_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+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/test/edmonds_karp_test.rb

@@ -0,0 +1,105 @@
+require 'test_helper'
+
+require 'rgl/edmonds_karp'
+require 'rgl/adjacency'
+
+include RGL
+
+class TestEdmondsKarp < Test::Unit::TestCase
+
+  def setup
+    @capacities_map = {
+        [1, 2] => 3,
+        [1, 4] => 3,
+        [2, 3] => 4,
+        [3, 1] => 3,
+        [3, 4] => 1,
+        [3, 5] => 2,
+        [4, 5] => 2,
+        [4, 6] => 6,
+        [5, 2] => 1,
+        [5, 7] => 1,
+        [6, 7] => 9
+    }
+
+    @graph = DirectedAdjacencyGraph[*@capacities_map.keys.flatten]
+
+    add_reverse_edges(@graph, @capacities_map)
+
+    @expected_flow = {
+        [1, 2] => 2, [2, 1] => -2,
+        [1, 4] => 3, [4, 1] => -3,
+        [2, 3] => 2, [3, 2] => -2,
+        [3, 4] => 1, [4, 3] => -1,
+        [3, 5] => 1, [5, 3] => -1,
+        [4, 5] => 0, [5, 4] => 0,
+        [4, 6] => 4, [6, 4] => -4,
+        [5, 7] => 1, [7, 5] => -1,
+        [6, 7] => 4, [7, 6] => -4,
+    }
+  end
+
+  def test_max_flow
+    assert_equal(@expected_flow, maximum_flow(1, 7))
+  end
+
+  def test_max_flow_with_lambda_capacities_map
+    capacities_lambda = lambda { |edge| @capacities_map[edge] }
+    assert_equal(@expected_flow, maximum_flow(1, 7), capacities_lambda)
+  end
+
+  def test_reverse_edges_validation
+    @graph.remove_edge(2, 1)
+    assert_raises(ArgumentError, 'reverse edge for (2, 1) is missing') { maximum_flow(1, 7) }
+  end
+
+  def test_missing_capacities_validation
+    @capacities_map.delete([3, 5])
+    assert_raises(ArgumentError, 'capacity for edge (3, 5) is missing') { maximum_flow(1, 7) }
+  end
+
+  def test_negative_capacities_validation
+    @capacities_map[[5, 2]] = -2
+    assert_raises(ArgumentError, 'capacity of edge (5, 2) is negative') { maximum_flow(1, 7) }
+  end
+
+  def test_zero_reverse_capacities_validation
+    @capacities_map[[7, 5]] = 1
+    assert_raises(ArgumentError, 'either (7, 5) or (5, 7) should have 0 capacity') { maximum_flow(1, 7) }
+  end
+
+  def test_zero_capacities
+    @capacities_map[[1, 5]] = 0
+    @capacities_map[[5, 1]] = 0
+    assert_equal(@expected_flow, maximum_flow(1, 7))
+  end
+
+  def test_equal_source_and_sink
+    assert_raises(ArgumentError, "source and sink can't be equal") { maximum_flow(1, 1) }
+  end
+
+  def test_directed_graph_validation
+    graph = AdjacencyGraph.new
+    graph.add_vertex(1)
+
+    assert_raises(NotDirectedError, 'Edmonds-Karp algorithm can only be applied to a directed graph') { graph.maximum_flow({}, 1, 2) }
+  end
+
+  def test_unreachable_sink
+    assert_equal({}, maximum_flow(1, 8))
+  end
+
+  private
+
+  def maximum_flow(source, sink, capacities_map = @capacities_map)
+    @graph.maximum_flow(capacities_map, source, sink)
+  end
+
+  def add_reverse_edges(graph, capacities_map)
+    capacities_map.keys.each do |(u, v)|
+      graph.add_edge(v, u)
+      capacities_map[[v, u]] = 0
+    end
+  end
+
+end

data/{tests/TestGraph.rb → test/graph_test.rb}

@@ -1,7 +1,7 @@
-require 'test/unit'
-require 'rgl/adjacency'
 require 'test_helper'
 
+require 'rgl/adjacency'
+
 include RGL
 
 class TestGraph < Test::Unit::TestCase
@@ -11,9 +11,9 @@ class TestGraph < Test::Unit::TestCase
   end
 
   def setup
-    @dg1 = DirectedAdjacencyGraph.new
-    @edges = [[1,2],[2,3],[2,4],[4,5],[1,6],[6,4]]
-    @edges.each do |(src,target)|
+    @dg1   = DirectedAdjacencyGraph.new
+    @edges = [[1, 2], [2, 3], [2, 4], [4, 5], [1, 6], [6, 4]]
+    @edges.each do |(src, target)|
       @dg1.add_edge(src, target)
     end
     @loan_vertices = [7, 8, 9]
@@ -58,7 +58,7 @@ class TestGraph < Test::Unit::TestCase
   end
 
   def test_set_edgelist_class
-    edges = @dg1.edges
+    edges              = @dg1.edges
     @dg1.edgelist_class=Array
     assert_equal edges, @dg1.edges
   end

data/test/graph_xml_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+require 'rgl/graphxml'
+require 'rgl/adjacency'
+require 'rgl/topsort'
+require 'rgl/connected_components'
+
+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).edges.sort.join
+    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)
+  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/test/implicit_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+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.join)
+  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.join)
+    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.join)
+    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.join)
+    assert(fg.directed?)
+  end
+end