iconofthestoneage-doodl 0.0.2 → 0.0.4

data/spec/breadth_first_search_spec.rb

@@ -0,0 +1,145 @@
+require "rspec_helper"
+
+require "breadth_first_search"
+require "graph"
+
+include Doodl
+
+describe "BreadthFirstSearch" do
+
+  before(:each) do
+    @empty = DirectedGraph.new
+    @graph = DirectedGraph.new
+  end
+
+
+  describe "All Graphs" do
+    before(:each) do
+      @node = @graph.add_node
+    end
+
+    it "should raise an ArgumentError when NOT initialized with a Graph and an node" do
+      lambda { BreadthFirstSearch.new(:do, :dont) }.should raise_error(ArgumentError)
+      lambda { BreadthFirstSearch.new(@empty_graph, :node) }.should raise_error(ArgumentError)
+      lambda { BreadthFirstSearch.new(@empty_graph, @node) }.should raise_error(ArgumentError)
+    end
+
+    it "should NOT raise an ArgumentError when initialized with a Graph with a Start-Node that is part of the Graph" do
+      node = @empty.add_node
+      lambda { DepthFirstSearch.new(@empty, node) }.should_not raise_error(ArgumentError)
+    end
+  end
+
+  describe "Unconnected Graph n[a, b, c] e[]" do
+    before(:each) do
+      @a = @graph.add_node
+      @b = @graph.add_node
+      @c = @graph.add_node
+    end
+
+    it "should return [start_node] when sent BreadthFirstSearch.new(graph, start_node).list" do
+      BreadthFirstSearch.new(@graph, @a).list.should == [@a]
+      BreadthFirstSearch.new(@graph, @b).list.should == [@b]
+      BreadthFirstSearch.new(@graph, @c).list.should == [@c]
+    end
+
+    it "should return INFINITY when sent BreadthFirstSearch.new(graph, start_node).dist[x] if x != start_node" do
+      BreadthFirstSearch.new(@graph, @a).dist[@b].should == INFINITY
+      BreadthFirstSearch.new(@graph, @a).dist[@c].should == INFINITY
+      BreadthFirstSearch.new(@graph, @b).dist[@a].should == INFINITY
+      BreadthFirstSearch.new(@graph, @b).dist[@c].should == INFINITY
+      BreadthFirstSearch.new(@graph, @c).dist[@a].should == INFINITY
+      BreadthFirstSearch.new(@graph, @c).dist[@b].should == INFINITY
+    end
+
+    it "should return 0 when sent BreadthFirstSearch.new(graph, start_node).dist[start_node]" do
+      BreadthFirstSearch.new(@graph, @a).dist[@a].should == 0
+      BreadthFirstSearch.new(@graph, @b).dist[@b].should == 0
+      BreadthFirstSearch.new(@graph, @c).dist[@c].should == 0
+    end
+
+    it "should visit a visitor" do
+      visitor = mock("visitor")
+      visitor.should_receive(:init).exactly(3).times
+      visitor.should_receive(:discover).once
+      visitor.should_receive(:examine_node).once
+      visitor.should_not_receive(:examine_node)
+      BreadthFirstSearch.new(@graph, @a, visitor)
+    end
+  end
+
+  describe "Adjacent Graph v:[a, b, c, d] e[(a b), (a c), (b,d)]" do
+    before(:each) do
+      @a = @graph.add_node
+      @b = @graph.add_node
+      @c = @graph.add_node
+      @d = @graph.add_node
+      @m = @graph.add_edge(@a, @b)
+      @n = @graph.add_edge(@b, @c)
+      @o = @graph.add_edge(@b, @d)
+    end
+
+    it "should return a list which starts with start_node when sent BreadthFirstSearch.new(graph, start_node).list" do
+      BreadthFirstSearch.new(@graph, @a).list.first.should == @a
+    end
+
+    it "should return the list [a, b, c, d]" do
+      BreadthFirstSearch.new(@graph, @a).list.should == [@a, @b, @c, @d]
+    end
+
+    it "should visit the visitor" do
+      visitor = mock("visitor")
+      visitor.should_receive(:init).exactly(4).times
+      visitor.should_receive(:discover).once.with(@graph, @a)
+      visitor.should_receive(:discover).once.with(@graph, @b)
+      visitor.should_receive(:discover).once.with(@graph, @c)
+      visitor.should_receive(:discover).once.with(@graph, @d)
+      visitor.should_receive(:examine_node).once.with(@graph, @a)
+      visitor.should_receive(:examine_node).once.with(@graph, @b)
+      visitor.should_receive(:examine_node).once.with(@graph, @c)
+      visitor.should_receive(:examine_node).once.with(@graph, @d)
+      visitor.should_receive(:examine_edge).once.with(@graph, @m)
+      visitor.should_receive(:examine_edge).once.with(@graph, @n)
+      visitor.should_receive(:examine_edge).once.with(@graph, @o)
+      BreadthFirstSearch.new(@graph, @a, visitor)
+    end
+
+  end
+
+  describe "Cyclic Graph v:[a, b, c, d] e[(a b), (a c), (c, a), (c, d)]" do
+    before(:each) do
+      @a = @graph.add_node
+      @b = @graph.add_node
+      @c = @graph.add_node
+      @d = @graph.add_node
+      @ab = @graph.add_edge(@a, @b)
+      @bc = @graph.add_edge(@b, @c)
+      @ca = @graph.add_edge(@c, @a)
+      @cd = @graph.add_edge(@c, @d)
+    end
+
+    it "should return the list [a, b, c, d]" do
+      BreadthFirstSearch.new(@graph, @a).list.should == [@a, @b, @c, @d]
+    end
+
+    it "should visit the visitor" do
+      visitor = mock("visitor")
+      visitor.should_receive(:init).exactly(4).times
+      visitor.should_receive(:discover).once.with(@graph, @a)
+      visitor.should_receive(:discover).once.with(@graph, @b)
+      visitor.should_receive(:discover).once.with(@graph, @c)
+      visitor.should_receive(:discover).once.with(@graph, @d)
+      visitor.should_receive(:examine_node).once.with(@graph, @a)
+      visitor.should_receive(:examine_node).once.with(@graph, @b)
+      visitor.should_receive(:examine_node).once.with(@graph, @c)
+      visitor.should_receive(:examine_node).once.with(@graph, @d)
+      visitor.should_receive(:examine_edge).once.with(@graph, @ab)
+      visitor.should_receive(:examine_edge).once.with(@graph, @bc)
+      visitor.should_receive(:examine_edge).once.with(@graph, @ca)
+      visitor.should_receive(:examine_edge).once.with(@graph, @cd)
+      BreadthFirstSearch.new(@graph, @a, visitor)
+    end
+
+  end
+
+end

data/spec/connected_components_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'rspec_helper'
+
+require "graph"
+require "connected_components"
+
+include Doodl
+
+describe ConnectedComponents do
+  before(:each) do
+    @graph = UndirectedGraph.new
+  end
+
+  it "should return 0 if the graph is empty when sent num_connected_components" do
+    ConnectedComponents.new(@graph).num_connected_components.should == 0
+  end
+
+  it "should return 1 if the graph has one node" do
+    @graph.add_node
+    ConnectedComponents.new(@graph).num_connected_components.should == 1
+  end
+
+  it "should return 2 if the graph has thow unlinked nodes" do
+    @graph.add_node
+    @graph.add_node
+    ConnectedComponents.new(@graph).num_connected_components.should == 2
+  end
+
+  it "should return 1 if the graph has two linked nodes" do
+    a = @graph.add_node
+    b = @graph.add_node
+    @graph.add_edge(a, b)
+    ConnectedComponents.new(@graph, a).num_connected_components.should == 1
+    ConnectedComponents.new(@graph, b).num_connected_components.should == 1
+    ConnectedComponents.new(@graph).num_connected_components.should == 1
+  end
+
+  it "should map the nodes to an integer id of their connected component" do
+    @a = @graph.add_node
+    @b = @graph.add_node
+    @c = @graph.add_node
+    @graph.add_edge(@b, @c)
+    cc = ConnectedComponents.new(@graph, @a)
+    cc.num_connected_components.should == 2
+    cc.component[@a].should == 1
+    cc.component[@b].should == 2
+    cc.component[@c].should == 2
+  end
+end

data/spec/depth_first_search_spec.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+require "rspec_helper"
+
+require "depth_first_search"
+require "graph"
+
+include Doodl
+
+describe "DepthFirstSearch" do
+
+  before(:each) do
+    @graph = DirectedGraph.new
+  end
+
+  describe "Graph: v:[a, b], e[(a b)]" do
+
+    before(:each) do
+      @a = @graph.add_node
+      @b = @graph.add_node
+      @e = @graph.add_edge(@a, @b)
+    end
+
+    it "should return [a, b] when sent #depth_first_list(a)" do
+      @dfs = DepthFirstSearch.new(@graph, @a)
+      @dfs.list.should == [@a, @b]
+      c = @graph.add_node
+      @dfs = DepthFirstSearch.new(@graph, @a).list.should == [@a, @b, c]
+    end
+
+    it "should return 1 when sent #d(b)" do
+      @dfs = DepthFirstSearch.new(@graph, @a)
+      @dfs.dist[@b].should == 1
+    end
+
+    it "should visit a start_node, discover, finish, examine" do
+      visitor = mock("visitor")
+      visitor.should_receive(:start_node).once.with(@graph, @a)
+      visitor.should_receive(:discover).once.with(@graph, @a)
+      visitor.should_receive(:discover).once.with(@graph, @b)
+      visitor.should_receive(:finish).once.with(@graph, @a)
+      visitor.should_receive(:finish).once.with(@graph, @b)
+      visitor.should_receive(:examine).once.with(@graph, @e)
+      @dfs = DepthFirstSearch.new(@graph, @a, visitor)
+    end
+
+  end
+
+  describe "Graph: v:[a, b, c, d], e[(a b) (a c) (b c) (b d) (d a)]" do
+
+    before(:each) do
+      @a = @graph.add_node
+      @b = @graph.add_node
+      @c = @graph.add_node
+      @d = @graph.add_node
+      @ab = @graph.add_edge(@a, @b)
+      @ac = @graph.add_edge(@a, @c)
+      @bd = @graph.add_edge(@b, @d)
+      @cd = @graph.add_edge(@c, @d)
+      @da = @graph.add_edge(@d, @a)
+    end
+
+    it "should return [a, b, d, c] when sent #depth_first_list(a)" do
+      DepthFirstSearch.new(@graph, @a).list.should == [@a, @b, @d, @c]
+      DepthFirstSearch.new(@graph, @a, nil, 1).list.should == [@a, @b, @c, @d]
+    end
+
+    it "should return the right distance when sent #d" do
+      DepthFirstSearch.new(@graph, @a).dist[@a].should == 0
+      DepthFirstSearch.new(@graph, @a).dist[@b].should == 1
+      DepthFirstSearch.new(@graph, @a).dist[@c].should == 3
+      DepthFirstSearch.new(@graph, @a).dist[@d].should == 2
+    end
+
+    it "should visit back edge (da)" do
+      visitor = mock("visitor")
+      visitor.should_receive(:back_edge).once.with(@graph, @da)
+      DepthFirstSearch.new(@graph, @a, visitor)
+    end
+
+    it "should visit forward/cross edge (cd)" do
+      visitor = mock("visitor")
+      visitor.should_receive(:forward_edge).once.with(@graph, @cd)
+      DepthFirstSearch.new(@graph, @a, visitor)
+    end
+
+  end
+
+end

data/spec/edge_spec.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require 'rspec_helper'
+
+require "edge"
+
+describe Doodl::Edge do
+  before(:each) do
+    @edge = Doodl::Edge.new(:s, :t)
+  end
+
+  it "should be initialized with a source and a target" do
+    lambda { Doodl::Edge.new(:s, :t) }.should_not raise_error(Exception)
+  end
+
+  it "should return true when sent #reflexive? and source and target are the same" do
+    edge = Doodl::Edge.new(:s, :s)
+    edge.reflexive?.should == true
+    edge = Doodl::Edge.new(:s, :t)
+    edge.reflexive?.should_not == true
+  end
+end
+
+describe Doodl::DirectedEdge do
+  before(:each) do
+  end
+
+  it "should return true when sent #directed?" do
+    Doodl::DirectedEdge.new(:x, :y).directed?.should == true
+  end
+
+  it "should be equal to an other edge with the same source and target" do
+    Doodl::DirectedEdge.new(:x, :y).should == Doodl::DirectedEdge.new(:x, :y)
+    Doodl::DirectedEdge.new(:x, :y).should_not == Doodl::DirectedEdge.new(:x, :z)
+    Doodl::DirectedEdge.new(:x, :y).should_not == Doodl::DirectedEdge.new(:z, :y)
+
+    Doodl::DirectedEdge.new(:x, :y).should_not == "anything"
+    Doodl::DirectedEdge.new(:x, :y).should_not == true
+    Doodl::DirectedEdge.new(:x, :y).should_not == nil
+  end
+
+end
+
+describe Doodl::UndirectedEdge do
+  before(:each) do
+  end
+
+  it "should return true when sent #directed?" do
+    Doodl::UndirectedEdge.new(:x, :y).directed?.should == false
+  end
+
+  it "should be equal to an other edge with the same source and target or with fliped source and targets" do
+    Doodl::UndirectedEdge.new(:x, :y).should == Doodl::UndirectedEdge.new(:x, :y)
+    Doodl::UndirectedEdge.new(:x, :y).should == Doodl::UndirectedEdge.new(:y, :x)
+    Doodl::UndirectedEdge.new(:x, :y).should_not == Doodl::UndirectedEdge.new(:z, :y)
+    Doodl::UndirectedEdge.new(:x, :y).should_not == Doodl::UndirectedEdge.new(:x, :z)
+  end
+end

data/spec/graph_generator_spec.rb

@@ -0,0 +1,277 @@
+# encoding: utf-8
+
+require 'rspec_helper'
+require 'graph'
+require 'graph_generator'
+
+include Doodl
+
+describe "All Graphs Generator" , :shared  => true do
+
+  describe "GraphGenerator Ring" do
+    it "should generate a graph with #size nodes when sent #gen_ring(size)" do
+      @graph.gen_ring_graph(0)
+      @graph.num_nodes.should == 0
+      @graph.gen_ring_graph(1)
+      @graph.num_nodes.should == 1
+      @graph.gen_ring_graph(2)
+      @graph.num_nodes.should == 2
+      @graph.gen_ring_graph(3)
+      @graph.num_nodes.should == 3
+      @graph.gen_ring_graph(4)
+      @graph.num_nodes.should == 4
+    end
+
+    it "should generate a graph with #size edges when sent #gen_ring(size)" do
+      @graph.gen_ring_graph(0)
+      @graph.num_edges.should == 0
+      @graph.gen_ring_graph(1)
+      @graph.num_edges.should == 0
+      @graph.gen_ring_graph(2)
+      if @graph.directed?
+        @graph.num_edges.should == 2
+      else
+        @graph.num_edges.should == 1
+      end
+      @graph.gen_ring_graph(3)
+      @graph.num_edges.should == 3
+    end
+
+    it "should generate a graph whose nodes have each an outdegree of one" do
+      @graph.gen_ring_graph(2)
+      if @graph.directed?
+        @graph.nodes.inject(true) { |memo, node| memo and (node.out_degree == 1) }.should == true
+        @graph.gen_ring_graph(3)
+        @graph.nodes.inject(true) { |memo, node| memo and (node.out_degree == 1) }.should == true
+        @graph.gen_ring_graph(4)
+        @graph.nodes.inject(true) { |memo, node| memo and (node.out_degree == 1) }.should == true
+      else
+        @graph.nodes.inject(true) { |memo, node| memo and (node.degree == 1) }.should == true
+        @graph.gen_ring_graph(3)
+        @graph.nodes.inject(true) { |memo, node| memo and (node.degree == 2) }.should == true
+        @graph.gen_ring_graph(4)
+        @graph.nodes.inject(true) { |memo, node| memo and (node.degree == 2) }.should == true        
+      end
+    end
+
+  end
+
+  describe "GraphGenerator Random" do
+    it "should generate a random graph of size num_of_nodes when sent gen_random_graph(num_of_nodes)" do
+      @graph.gen_random_graph(0)
+      @graph.num_nodes.should == 0
+      @graph.gen_random_graph(1)
+      @graph.num_nodes.should == 1
+      @graph.gen_random_graph(2)
+      @graph.num_nodes.should == 2
+      @graph.gen_random_graph(3)
+      @graph.num_nodes.should == 3
+    end
+
+    it "should generate a random graph with random edges when sent gen_random(num_nodes)" do
+      @graph.gen_random_graph(0)
+      @graph.num_edges.should == 0
+      @graph.gen_random_graph(1)
+      @graph.num_edges.should == 0
+      @graph.gen_random_graph(2)
+      if @graph.directed?
+        @graph.num_edges.should <= 2
+      else
+        @graph.num_edges.should <= 1
+      end
+      @graph.num_edges.should >= 0
+      @graph.gen_random_graph(3)
+      if @graph.directed?
+        @graph.num_edges.should <= 3*2
+      else
+        @graph.num_edges.should <= 3
+      end
+      @graph.num_edges.should >= 0
+    end
+
+    it "should generate a random graph with num_of_edges edges when sent gen_random(num_nodes, num_edges)" do
+      @graph.gen_random_graph(0)
+      @graph.num_edges.should == 0
+      @graph.gen_random_graph(1, 0)
+      @graph.num_edges.should == 0
+      @graph.gen_random_graph(2, 1)
+      @graph.num_edges.should == 1
+      if @graph.directed?
+        @graph.gen_random_graph(2, 2)
+        @graph.num_edges.should == 2
+      end
+      @graph.gen_random_graph(3, 1)
+      @graph.num_edges.should == 1
+      @graph.gen_random_graph(3, 3)
+      @graph.num_edges.should == 3
+      if @graph.directed?
+        @graph.gen_random_graph(3, 6)
+        @graph.num_edges.should == 6      
+      end
+    end
+
+    it "should raise an ArgumentError when num_edges is greater than the # of possible edges in a graph" do
+      lambda { @graph.gen_random_graph(0, 1) }.should raise_error(ArgumentError)
+      lambda { @graph.gen_random_graph(1, 2) }.should raise_error(ArgumentError)
+      lambda { @graph.gen_random_graph(3, 7) }.should raise_error(ArgumentError)    
+    end
+
+  end
+
+  describe "GraphGenerator Connected" do
+
+    def max_edges(graph)
+      num_nodes = graph.num_nodes
+      if graph.directed?
+        num_nodes * (num_nodes-1)
+      else
+        num_nodes * (num_nodes-1) / 2
+      end
+    end
+
+    it "should generate a graph of #size nodes when sent gen_connected(size)" do
+      @graph.gen_connected_graph(0)
+      @graph.num_nodes.should == 0
+      @graph.gen_connected_graph(1)
+      @graph.num_nodes.should == 1
+      @graph.gen_connected_graph(2)
+      @graph.num_nodes.should == 2
+      @graph.gen_connected_graph(3)
+      @graph.num_nodes.should == 3
+    end
+
+    it "should generate a graph with n*n-1 edges (directed) or n*(n-1)/2 edges (undirected)" do
+      @graph.gen_connected_graph(0)
+      @graph.num_edges.should == 0
+      @graph.gen_connected_graph(1)
+      @graph.num_edges.should == 0
+      @graph.gen_connected_graph(2)
+      @graph.num_edges.should == max_edges(@graph)
+      @graph.gen_connected_graph(3)
+      @graph.num_edges.should == max_edges(@graph)
+      @graph.gen_connected_graph(4)
+      @graph.num_edges.should == max_edges(@graph)
+      @graph.gen_connected_graph(9)
+      @graph.num_edges.should == max_edges(@graph)
+    end
+
+    it "should generate a graph whose nodes have each an outdegree/degree of num_edges-1" do
+      if @graph.directed?
+        @graph.gen_connected_graph(2)
+        @graph.nodes.inject(true) { |memo, node| memo and (node.out_degree == 1) }.should == true
+        @graph.gen_connected_graph(3)
+        @graph.nodes.inject(true) { |memo, node| memo and (node.out_degree == 2) }.should == true
+        @graph.gen_connected_graph(4)
+        @graph.nodes.inject(true) { |memo, node| memo and (node.out_degree == 3) }.should == true
+      else
+        @graph.gen_connected_graph(2)
+        @graph.nodes.inject(true) { |memo, node| memo and (node.degree == 1) }.should == true
+        @graph.gen_connected_graph(3)
+        @graph.nodes.inject(true) { |memo, node| memo and (node.degree == 2) }.should == true
+        @graph.gen_connected_graph(4)
+        @graph.nodes.inject(true) { |memo, node| memo and (node.degree == 3) }.should == true        
+      end
+    end
+
+  end
+
+  describe "GraphGenerator Linear" do
+    it "should generate a graph with #size nodes when sent #gen_linear_graph(size)" do
+      @graph.gen_linear_graph(0)
+      @graph.num_nodes.should == 0
+      @graph.gen_linear_graph(1)
+      @graph.num_nodes.should == 1
+      @graph.gen_linear_graph(2)
+      @graph.num_nodes.should == 2
+      @graph.gen_linear_graph(3)
+      @graph.num_nodes.should == 3
+      @graph.gen_linear_graph(4)
+      @graph.num_nodes.should == 4
+    end
+
+    it "should generate a graph with #size edges when sent #gen_linear_graph(size)" do
+      @graph.gen_linear_graph(0)
+      @graph.num_edges.should == 0
+      @graph.gen_linear_graph(1)
+      @graph.num_edges.should == 0
+      @graph.gen_linear_graph(2)
+      @graph.num_edges.should == 1
+      @graph.gen_linear_graph(3)
+      @graph.num_edges.should == 2
+    end
+
+    it "should generate a graph whose nodes have each an outdegree of one" do
+      @graph.gen_linear_graph(5)
+      if @graph.directed?
+        @graph.nodes.inject(true) { |memo, node| memo and (node.out_degree == 1 or node == @graph.nodes.last) }.should == true
+      else
+        @graph.nodes.inject(true) { |memo, node| memo and (node.degree == 2 or 
+          ((node == @graph.nodes.first or node == @graph.nodes.last) and node.degree == 1))
+        }.should == true
+      end
+    end
+
+  end
+
+  describe "GraphGenerator Mesh" do
+    it "should generate a graph with #rows*colums nodes when sent #gen_linear_graph(rows, colums)" do
+      @graph.gen_mesh_graph(0, 0)
+      @graph.num_nodes.should == 0
+      @graph.gen_mesh_graph(1, 1)
+      @graph.num_nodes.should == 1
+      @graph.gen_mesh_graph(1, 2)
+      @graph.num_nodes.should == 2
+      @graph.gen_mesh_graph(1, 3)
+      @graph.num_nodes.should == 3
+
+      @graph.gen_mesh_graph(2, 1)
+      @graph.num_nodes.should == 2
+      @graph.gen_mesh_graph(3, 1)
+      @graph.num_nodes.should == 3
+
+      @graph.gen_mesh_graph(2, 2)
+      @graph.num_nodes.should == 4
+      @graph.gen_mesh_graph(3, 3)
+      @graph.num_nodes.should == 9
+
+      @graph.gen_mesh_graph(2)
+      @graph.num_nodes.should == 4
+    end
+
+    it "should have edges" do
+      @graph.gen_mesh_graph(0, 0)
+      @graph.num_edges.should == 0
+      @graph.gen_mesh_graph(1, 0)
+      @graph.num_edges.should == 0
+      @graph.gen_mesh_graph(1, 1)
+      @graph.num_edges.should == 0
+      @graph.gen_mesh_graph(1, 2)
+      @graph.num_edges.should == 1
+      @graph.gen_mesh_graph(2, 1)
+      @graph.num_edges.should == 1
+      @graph.gen_mesh_graph(2, 2)
+      @graph.num_edges.should == 4
+      @graph.gen_mesh_graph(2)
+      @graph.num_edges.should == 4
+      @graph.gen_mesh_graph(3)
+      @graph.num_edges.should == 12
+    end
+  end
+
+end
+
+describe "DirectedGraph" do
+  before(:each) do
+    @graph = DirectedGraph.new
+  end
+  
+  it_should_behave_like "All Graphs Generator"
+end
+
+describe "UndirectedGraph" do
+  before(:each) do
+    @graph = UndirectedGraph.new
+  end
+  
+  it_should_behave_like "All Graphs Generator"
+end