rgl 0.4.0 → 0.5.0

data/rakelib/dep_graph.rake

@@ -13,9 +13,10 @@ end
 desc "Generate dependency graph of rake tasks"
 task :dep_graph do |task|
   this_task = task.name
-  dep = RGL::ImplicitGraph.new { |g|
+
+  dep = RGL::ImplicitGraph.new do |g|
     # vertices of the graph are all defined tasks without this task
-	g.vertex_iterator do |b|
+    g.vertex_iterator do |b|
       Rake::Task.tasks.each do |t|
         b.call(t) unless t.name == this_task
       end
@@ -23,7 +24,7 @@ task :dep_graph do |task|
     # neighbors of task t are its prerequisites
     g.adjacent_iterator { |t, b| t.prerequisites.each(&b) }
     g.directed = true
-  }
+  end
 
   dep.write_to_graphic_file('png', this_task)
   puts "Wrote dependency graph to #{this_task}.png."

data/test/bellman_ford_test.rb

@@ -0,0 +1,187 @@
+require 'test_helper'
+
+require 'rgl/bellman_ford'
+require 'rgl/adjacency'
+
+include RGL
+
+class TestBellmanFord < Test::Unit::TestCase
+
+  def setup
+    @graph = AdjacencyGraph[1,2, 1,3, 2,3, 2,4, 3,4]
+
+    @edge_weights = {
+        [1, 2] => 10,
+        [1, 3] => 1,
+        [2, 3] => 1,
+        [2, 4] => 1,
+        [3, 4] => 10
+    }
+
+    @edge_weights_lambda = lambda { |edge| @edge_weights[edge] }
+  end
+
+  def test_shortest_paths_search
+    assert_equal(
+        {
+            1 => [1],
+            2 => [1, 3, 2],
+            3 => [1, 3],
+            4 => [1, 3, 2, 4]
+        },
+        shortest_paths(1)
+    )
+  end
+
+  def test_shortest_paths_search_with_lambda
+    assert_equal(
+        {
+            1 => [1],
+            2 => [1, 3, 2],
+            3 => [1, 3],
+            4 => [1, 3, 2, 4]
+        },
+        shortest_paths(1, @edge_weights_lambda)
+    )
+  end
+
+  def test_shortest_paths_search_with_unreachable_vertex
+    @graph.add_vertex(5)
+
+    assert_equal(
+        {
+            1 => [1],
+            2 => [1, 3, 2],
+            3 => [1, 3],
+            4 => [1, 3, 2, 4],
+            5 => nil
+        },
+        shortest_paths(1)
+    )
+  end
+
+  def test_shortest_paths_with_negative_weights
+    # can't use an undirected graph with a negative weighted edge here, because a negative weighted undirected edge is
+    # already a negative weighted cycle and therefore Bellman-Ford can't be applied for such graph
+    @graph = DirectedAdjacencyGraph[1,2, 1,3, 2,3, 2,4, 3,2, 3,4]
+    @edge_weights[[3, 2]] = 1
+    @edge_weights[[3, 4]] = -1
+
+    assert_equal(
+        {
+            1 => [1],
+            2 => [1, 3, 2],
+            3 => [1, 3],
+            4 => [1, 3, 4]
+        },
+        shortest_paths(1)
+    )
+  end
+
+  def test_missing_edge_weight
+    @edge_weights.delete([2, 3])
+    assert_raises(ArgumentError, 'weight of edge (2, 3) is not defined') { shortest_paths(1) }
+  end
+
+  def test_negative_cycles
+    @graph = DirectedAdjacencyGraph[1,2, 1,3, 2,3, 2,4, 3,4, 4,2]
+    @edge_weights[[4, 2]] = 1
+    @edge_weights[[3, 4]] = -3 # cycle 2-3-4-2 has negative weight
+
+    assert_raises(ArgumentError, 'there is a negative-weight cycle including edge (3, 4)') { shortest_paths(1) }
+  end
+
+  def test_visitor
+    visitor = BellmanFordVisitor.new(@graph)
+
+    events = []
+
+    %w[examine_edge edge_relaxed edge_not_relaxed edge_minimized edge_not_minimized].each do |event|
+      visitor.send("set_#{event}_event_handler") { |*args| events << { event.to_sym => args } }
+    end
+
+    @graph.bellman_ford_shortest_paths(@edge_weights, 1, visitor)
+
+    assert_equal(
+        [
+            # first iteration
+            { :examine_edge     => [1, 2] },
+            { :edge_relaxed     => [1, 2] },
+            { :examine_edge     => [2, 1] },
+            { :edge_not_relaxed => [2, 1] },
+            { :examine_edge     => [1, 3] },
+            { :edge_relaxed     => [1, 3] },
+            { :examine_edge     => [3, 1] },
+            { :edge_not_relaxed => [3, 1] },
+            { :examine_edge     => [2, 3] },
+            { :edge_not_relaxed => [2, 3] },
+            { :examine_edge     => [3, 2] },
+            { :edge_relaxed     => [3, 2] },
+            { :examine_edge     => [2, 4] },
+            { :edge_relaxed     => [2, 4] },
+            { :examine_edge     => [4, 2] },
+            { :edge_not_relaxed => [4, 2] },
+            { :examine_edge     => [3, 4] },
+            { :edge_not_relaxed => [3, 4] },
+            { :examine_edge     => [4, 3] },
+            { :edge_not_relaxed => [4, 3] },
+            # second iteration
+            { :examine_edge     => [1, 2] },
+            { :edge_not_relaxed => [1, 2] },
+            { :examine_edge     => [2, 1] },
+            { :edge_not_relaxed => [2, 1] },
+            { :examine_edge     => [1, 3] },
+            { :edge_not_relaxed => [1, 3] },
+            { :examine_edge     => [3, 1] },
+            { :edge_not_relaxed => [3, 1] },
+            { :examine_edge     => [2, 3] },
+            { :edge_not_relaxed => [2, 3] },
+            { :examine_edge     => [3, 2] },
+            { :edge_not_relaxed => [3, 2] },
+            { :examine_edge     => [2, 4] },
+            { :edge_not_relaxed => [2, 4] },
+            { :examine_edge     => [4, 2] },
+            { :edge_not_relaxed => [4, 2] },
+            { :examine_edge     => [3, 4] },
+            { :edge_not_relaxed => [3, 4] },
+            { :examine_edge     => [4, 3] },
+            { :edge_not_relaxed => [4, 3] },
+            # thirds iteration
+            { :examine_edge     => [1, 2] },
+            { :edge_not_relaxed => [1, 2] },
+            { :examine_edge     => [2, 1] },
+            { :edge_not_relaxed => [2, 1] },
+            { :examine_edge     => [1, 3] },
+            { :edge_not_relaxed => [1, 3] },
+            { :examine_edge     => [3, 1] },
+            { :edge_not_relaxed => [3, 1] },
+            { :examine_edge     => [2, 3] },
+            { :edge_not_relaxed => [2, 3] },
+            { :examine_edge     => [3, 2] },
+            { :edge_not_relaxed => [3, 2] },
+            { :examine_edge     => [2, 4] },
+            { :edge_not_relaxed => [2, 4] },
+            { :examine_edge     => [4, 2] },
+            { :edge_not_relaxed => [4, 2] },
+            { :examine_edge     => [3, 4] },
+            { :edge_not_relaxed => [3, 4] },
+            { :examine_edge     => [4, 3] },
+            { :edge_not_relaxed => [4, 3] },
+            # post-iteration check
+            { :edge_minimized   => [1, 2] },
+            { :edge_minimized   => [1, 3] },
+            { :edge_minimized   => [2, 3] },
+            { :edge_minimized   => [2, 4] },
+            { :edge_minimized   => [3, 4] }
+        ],
+        events
+    )
+  end
+
+  private
+
+  def shortest_paths(source, edge_weights = @edge_weights)
+    @graph.bellman_ford_shortest_paths(edge_weights, source)
+  end
+
+end

data/test/bipartite_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+require 'rgl/bipartite'
+require 'rgl/adjacency'
+
+include RGL
+
+class TestBipartite < Test::Unit::TestCase
+
+  def test_bipartite_sets
+    assert_equal([[1, 2, 3], [4, 5, 6]], bipartite_sets(AdjacencyGraph[1,5, 1,6, 2,4, 2,5, 3,4, 3,5, 3,6]))
+  end
+
+  def test_bipartite_sets_for_non_bipartite_graph
+    assert_equal(nil, bipartite_sets(AdjacencyGraph[1,4, 1,5, 2,3, 2,4, 2,5, 3,5]))
+  end
+
+  def test_bipartite_sets_for_directed_graph
+    assert_raise(NotUndirectedError, 'bipartite sets can only be found for an undirected graph') do
+      DirectedAdjacencyGraph.new.bipartite_sets
+    end
+  end
+
+  def test_bipartite_sets_for_bipartite_disconnected_graph
+    assert_equal([[1, 3], [2, 4]], bipartite_sets(AdjacencyGraph[1,2, 3,4]))
+  end
+
+  def test_bipartite_sets_for_non_bipartite_disconnected_graph
+    assert_equal(nil, bipartite_sets(AdjacencyGraph[1,2, 3,4, 4,5, 5,3]))
+  end
+
+  def test_bipartite
+    assert(AdjacencyGraph[1,2, 2,3].bipartite?)
+  end
+
+  def test_not_bipartite
+    assert(!AdjacencyGraph[1,2, 2,3, 3,1].bipartite?)
+  end
+
+  private
+
+  def bipartite_sets(graph)
+    sets = graph.bipartite_sets
+    sets && sets.map { |set| set.sort }.sort
+  end
+
+end

data/test/components_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+require 'rgl/connected_components'
+require 'rgl/adjacency'
+
+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(<<-END
+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
+    )
+  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)
+
+    res = vis.comp_map.to_a.sort.reduce({}) { |res, a|
+      if res.key?(a[1])
+        res[a[1]] << a[0]
+      else
+        res[a[1]] = [a[0]]
+      end
+      res
+    }
+
+    std_res = res.to_a.map {
+        |a|
+      [a[1][0], a[1]]
+    }.sort
+
+    assert_equal([["a", ["a", "b", "c", "h", "i"]], ["d", ["d", "e"]], ["f", ["f", "g"]], ["j", ["j"]]], std_res)
+  end
+end

data/test/cycles_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+require 'rgl/adjacency'
+
+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/test/dijkstra_test.rb

@@ -0,0 +1,148 @@
+require 'test_helper'
+
+require 'rgl/dijkstra'
+require 'rgl/adjacency'
+
+include RGL
+
+class TestDijkstra < Test::Unit::TestCase
+
+  def setup
+    @graph = AdjacencyGraph[1,2, 1,3, 2,3, 2,4, 3,4]
+
+    @edge_weights = {
+        [1, 2] => 10,
+        [1, 3] => 1,
+        [2, 3] => 1,
+        [2, 4] => 1,
+        [3, 4] => 10
+    }
+
+    @edge_weights_lambda = lambda { |edge| @edge_weights[edge] }
+  end
+
+  def test_shortest_path_search
+    assert_equal([1, 3, 2, 4], shortest_path(1, 4))
+  end
+
+  def test_shortest_path_search_with_lambda
+    assert_equal([1, 3, 2, 4], shortest_path(1, 4, @edge_weights_lambda))
+  end
+
+  def test_shortest_path_to_the_source
+    assert_equal([1], shortest_path(1, 1))
+  end
+
+  def test_path_for_unreachable_vertex
+    @graph.add_vertex(5)
+    assert_equal(nil, shortest_path(1, 5))
+  end
+
+  def test_shortest_paths_search
+    assert_equal(
+        {
+            1 => [1],
+            2 => [1, 3, 2],
+            3 => [1, 3],
+            4 => [1, 3, 2, 4]
+        },
+        shortest_paths(1)
+    )
+  end
+
+  def test_shortest_paths_search_with_lambda
+    assert_equal(
+        {
+            1 => [1],
+            2 => [1, 3, 2],
+            3 => [1, 3],
+            4 => [1, 3, 2, 4]
+        },
+        shortest_paths(1, @edge_weights_lambda)
+    )
+  end
+
+  def test_shortest_paths_search_with_unreachable_vertex
+    @graph.add_vertex(5)
+
+    assert_equal(
+        {
+            1 => [1],
+            2 => [1, 3, 2],
+            3 => [1, 3],
+            4 => [1, 3, 2, 4],
+            5 => nil
+        },
+        shortest_paths(1)
+    )
+  end
+
+  def test_visitor
+    visitor = DijkstraVisitor.new(@graph)
+
+    events = []
+
+    %w[examine_vertex examine_edge edge_relaxed edge_not_relaxed finish_vertex].each do |event|
+      visitor.send("set_#{event}_event_handler") { |*args| events << { event.to_sym => args } }
+    end
+
+    @graph.dijkstra_shortest_paths(@edge_weights, 1, visitor)
+
+    assert_equal(
+        [
+            { :examine_vertex => [1] },
+            { :examine_edge   => [1, 2] },
+            { :edge_relaxed   => [1, 2] },
+            { :examine_edge   => [1, 3] },
+            { :edge_relaxed   => [1, 3] },
+            { :finish_vertex  => [1] },
+            { :examine_vertex => [3] },
+            { :examine_edge   => [3, 2] },
+            { :edge_relaxed   => [3, 2] },
+            { :examine_edge   => [3, 4] },
+            { :edge_relaxed   => [3, 4] },
+            { :finish_vertex  => [3] },
+            { :examine_vertex => [2] },
+            { :examine_edge   => [2, 4] },
+            { :edge_relaxed   => [2, 4] },
+            { :finish_vertex  => [2] },
+            { :examine_vertex => [4] },
+            { :finish_vertex  => [4] },
+        ],
+        events
+    )
+  end
+
+  def test_negative_edge_weight
+    @edge_weights[[2, 3]] = -7
+    assert_raises(ArgumentError, 'weight of edge (2, 3) is negative') { shortest_path(1, 5) }
+  end
+
+  def test_negative_edge_weight_with_lambda
+    @edge_weights[[2, 3]] = -7
+    assert_raises(ArgumentError, 'weight of edge (2, 3) is negative') { shortest_path(1, 5, @edge_weights_lambda) }
+  end
+
+  def test_missing_edge_weight
+    @edge_weights.delete([2, 3])
+    assert_raises(ArgumentError, 'weight of edge (2, 3) is not defined') { shortest_path(1, 5) }
+  end
+
+  def test_edge_weights_map_object_in_argument
+    weights_map = EdgePropertiesMap.new(@edge_weights, @graph.directed?)
+    dijkstra    = DijkstraAlgorithm.new(@graph, weights_map, DijkstraVisitor.new(@graph))
+
+    assert_equal([1, 3, 2, 4], dijkstra.shortest_path(1, 4))
+  end
+
+  private
+
+  def shortest_path(source, target, edge_weights = @edge_weights)
+    @graph.dijkstra_shortest_path(edge_weights, source, target)
+  end
+
+  def shortest_paths(source, edge_weights = @edge_weights)
+    @graph.dijkstra_shortest_paths(edge_weights, source)
+  end
+
+end