plexus 0.5.4 → 0.5.5

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--color
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,59 @@
+require File.expand_path("../../lib/plexus.rb",  __FILE__)
+
+require 'plexus'
+include Plexus
+
+module AncestryHelper
+  # "Algorithmic Graph Theory and Perfect Graphs", Martin Charles
+  # Golumbic, 1980, Academic Press, page 38, Figure 2.6
+  def assign_dfsnumber_ancestry(graph, dfsnumber, father, start)
+    i = 0
+    dfsnumber.clear
+    father.clear
+    ev = Proc.new {|v| dfsnumber[v]     = (i+=1)   }
+    te = Proc.new {|e| father[e.target] = e.source }
+    graph.dfs({:enter_vertex => ev, :tree_edge => te, :start => start})
+  end
+
+  # "Algorithmic Graph Theory and Perfect Graphs", Martin Charles
+  # Golumbic, 1980, Academic Press, page 40, Figure 2.7
+  def assign_bfsnumber_ancestry(graph, bfsnum, level, father, start)
+    i = 0
+    bfsnum.clear
+    level.clear
+    father.clear
+    rt = Proc.new {|v| level[v] = 0 }
+    ev = Proc.new {|v| bfsnum[v]=(i+=1);level[v]=(level[father[v]]+1) if father[v]}
+    te = Proc.new {|e| father[e.target] = e.source }
+    graph.dfs({:enter_vertex => ev, :tree_edge => te,
+               :root_vertex => rt, :start => start})
+  end
+
+
+  # Is v an ancestor of u?
+  def ancestor?(father, u, v)
+    i = 1
+    while v
+      return i if father[v] == u
+      v = father[v]
+      i += 1
+    end; nil
+  end
+
+  # Is there any relationship?
+  def related?(father,u,v)
+    ancestor?(father,u,v) or ancestor?(father,v,u)
+  end
+
+end
+
+RSpec.configure do |config|
+  # Remove this line if you don't want RSpec's should and should_not
+  # methods or matchers
+  require 'rspec/expectations'
+  config.include RSpec::Matchers
+  config.include AncestryHelper
+
+  # == Mock Framework
+  config.mock_with :rspec
+end

data/spec/strong_components_spec.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Strong Components" do # :nodoc:
+  
+  # Test from boost strong_components.cpp
+  # Original Copyright 1997-2001, University of Notre Dame.
+  # Original Authors: Andrew Lumsdaine, Lie-Quan Lee, Jermey G. Siek
+  describe "boost" do
+    it do
+      g = Digraph[ 'a', 'b',  'a', 'f',  'a', 'h',
+                   'b', 'c',  'b', 'a',
+                   'c', 'd',  'c', 'b',
+                   'd', 'e',
+                   'e', 'd',
+                   'f', 'g',
+                   'g', 'f',  'g', 'd',
+                   'h', 'i',
+                   'i', 'h',  'i', 'j',  'i', 'e',  'i', 'c']
+
+      c = g.strong_components.map {|x| x.sort}
+      g.vertices.size.should == 10
+      c.size.should == 4
+      c.should include(['d','e'])
+      c.should include(['f','g'])
+      c.should include(['j'])
+      c.should include(['a','b','c','h','i'])
+      
+      cg = g.condensation
+      cg_vertices = cg.map {|v| v.sort}
+      cg_vertices.size.should == 4
+      cg_vertices.should include(['j'])
+      cg_vertices.should include(['d','e'])
+      cg_vertices.should include(['f', 'g'])
+      cg_vertices.should include(['a', 'b', 'c', 'h', 'i'])
+      cg.edges.map {|e| [e.source.sort.join, e.target.sort.join] }.to_a.sort.should ==
+        [["abchi", "abchi"], ["abchi", "de"], ["abchi", "fg"], ["abchi", "j"], ["de", "de"], ["fg", "de"], ["fg", "fg"]]
+    end
+  end
+  
+
+  # Figure #3, from 'Depth-First Search and Linear Graph Algorithms'
+  # by Robert Tarjan, SIAM J. Comput. Vol 1, No.2, June 1972
+  describe "tarjan_fig_3" do
+    it do
+      g = Digraph[ 1,2,
+                   2,3, 2,8,
+                   3,4, 3,7,
+                   4,5,
+                   5,3, 5,6,
+                   7,4, 7,6,
+                   8,1, 8,7 ]
+      
+      c = g.strong_components.map {|x| x.sort}
+      g.vertices.size.should == 8
+      c.size.should == 3
+      c.should include([6])
+      c.should include([1,2,8]) 
+      c.should include([3,4,5,7])
+    end
+  end
+end

data/spec/triangulated_spec.rb

@@ -0,0 +1,125 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Triangulated" do #:nodoc:
+
+  describe "berge_mystery" do
+    it do
+      berge_mystery = UndirectedGraph[
+                                      :abe,       :eddie, 
+                                      :abe,       :burt,
+                                      :abe,       :desmond,
+                                      :eddie,     :burt,
+                                      :eddie,     :ida,
+                                      :eddie,     :charlotte,
+                                      :charlotte, :ida,
+                                      :charlotte, :desmond,
+                                      :burt,      :ida,
+                                      :ida,       :desmond]
+      
+      berge_mystery.should_not be_triangulated
+      berge_mystery.remove_vertex!(:desmond)
+      berge_mystery.should be_triangulated
+      berge_mystery.chromatic_number.should == 3
+    end
+  end
+  
+  describe "house" do
+    it do
+      house = UndirectedGraph[
+                              :roof,            :left_gutter,
+                              :roof,            :right_gutter,
+                              :left_gutter,     :left_foundation,
+                              :right_gutter,    :right_foundation,
+                              :left_foundation, :right_foundation
+                             ]
+      house.should_not be_triangulated
+      house.remove_vertex!(:left_foundation) # Becomes a bulls head graph
+      house.should be_triangulated
+      ##
+      # This assertion wasn't running correctly in GRATR (`assert`
+      # when it should have been `assert_equal`), failing now, and
+      # may not be valid.
+      # house.chromatic_number.should == 3
+    end
+    
+  end
+  
+  # A triangulated, but not interval graph test
+  describe "non_interval" do
+    it do
+      non_interval = UndirectedGraph[
+                                     :ao, :ai,
+                                     :ai, :bi,
+                                     :ai, :ci,
+                                     :bo, :bi,
+                                     :bi, :ci,
+                                     :co, :ci
+                                    ]
+      non_interval.should be_triangulated
+      non_interval.chromatic_number.should == 3
+    end
+    
+  end
+  
+  describe "simple" do
+    it do
+      simple = UndirectedGraph[
+                               :a, :b,
+                               :b, :c,
+                               :c, :d,
+                               :d, :e, 
+                               :e, :f,
+                               :f, :g,
+                               :g, :a,
+                               :g, :b,
+                               :b, :f,
+                               :f, :c,
+                              ]
+      simple.should_not be_triangulated
+      simple.add_edge!(:c, :e)
+      simple.should be_triangulated
+      simple.chromatic_number.should == 3
+      UndirectedGraph[:a, :b].chromatic_number.should == 2
+    end
+  end
+  
+  describe "simple2" do
+    it do
+      simple2 = UndirectedGraph[
+                                :x, :p,
+                                :p, :z,
+                                :z, :r,
+                                :r, :x,
+                                :p, :y,
+                                :y, :r,
+                                :y, :q,
+                                :q, :z]
+      simple2.should_not be_triangulated
+    end
+  end
+  
+  describe "lexicographic_queue" do
+    it do
+      q = Plexus::Search::LexicographicQueue.new([1,2,3,4,5,6,7,8,9])
+      q.pop.should == 9
+      q.add_lexeme([3,4,5,6,7,8])
+      q.pop.should == 8
+      q.add_lexeme([2,6,7,9])
+      q.pop.should == 7
+      q.add_lexeme([8,9])
+      q.pop.should == 6
+      q.add_lexeme([1,5,8,9])
+      q.pop.should == 5
+      q.add_lexeme([6,9])
+      q.pop.should == 4
+      q.add_lexeme([3,9])
+      q.pop.should == 3
+      q.add_lexeme([4,9])
+      q.pop.should == 2
+      q.add_lexeme([8])
+      q.pop.should == 1
+      q.pop.should == nil
+    end
+  end
+  
+end

data/spec/undirected_graph_spec.rb

@@ -0,0 +1,220 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "UndirectedGraph" do # :nodoc:
+
+  before do
+    @single = UndirectedGraph[1,2, 2,3, 3,4, 4,4, 1,2, 2,3]
+    @dups   = UndirectedPseudoGraph[1,2, 2,3, 3,4, 4,4, 1,2, 2,3]
+    @loops  = UndirectedMultiGraph[1,2, 2,3, 3,4, 4,4, 1,2, 2,3]
+  end
+
+  describe "new" do
+    it do
+      @single.should == UndirectedGraph[1,2, 2,3, 3,4, 4,4]
+      @dups.should == UndirectedPseudoGraph[1,2, 2,3, 3,4, 4,4, 1,2, 2,3]
+      @loops.should == UndirectedMultiGraph[1,2, 2,3, 3,4, 4,4, 1,2, 2,3]
+      proc { UndirectedGraph.new(:bomb) }.should raise_error(ArgumentError)
+      proc { UndirectedGraph.new(1) }.should raise_error(ArgumentError)
+      UndirectedGraph.new(@single).should == @single
+    end
+  end
+
+  describe "edges" do
+    it do
+      @single.edges.should include(Edge[1,2])
+      @single.edges.should include(Edge[2,3])
+      @single.edges.should include(Edge[3,4])
+      @single.edges.should_not include(Edge[4,4])
+      @loops.edges.should include(MultiEdge[4,4])
+      @single.edges.should include(Edge[1,2])
+      @single.edges.should include(Edge[2,3])
+      @single.edges.should_not include(Edge[1,3])
+      @single.should be_edge(2,3)
+      @single.should_not be_edge(1,4)
+      @single.should be_edge(Edge[1,2])
+      @single.add_edge!(5,5).should_not be_edge(5,5)
+      @dups.add_edge!(5,5).should_not be_edge(5,5)
+      @loops.add_edge!(5,5).should be_edge(5,5)
+      @single.remove_edge!(5,5).should_not be_edge(5,5)
+    end
+  end
+
+  describe "vertices" do
+    it do
+      @single.vertices.to_a.sort.should == [1,2,3,4]
+      @single.add_vertex!(5).to_a.sort.should == [1,2,3,4,5]
+      @single.remove_vertex!(3).to_a.sort.should == [1,2,4,5]
+      @single.should_not be_vertex(3)
+      @single.should_not be_edge(2,3)
+      @single.should_not be_edge(3,4)
+    end
+  end
+
+  describe "properties" do
+    it do
+      @single.should_not be_directed
+      @single.should_not be_empty
+      UndirectedGraph.new.should be_empty
+      @single.size.should == 4
+      @dups.size.should == 4
+      @single.num_vertices.should == 4
+      @dups.num_vertices.should == 4
+      @single.num_edges.should == 3
+      @loops.num_edges.should == 6
+      @dups.num_edges.should == 5
+    end
+  end
+
+  describe "merge" do
+    it do
+      @dups.merge(@single)
+      @dups.num_edges.should == 8
+        @dups.vertices.sort.should == [1,2,3,4]
+    end
+  end
+
+  describe "operators" do
+    it do
+      result = @single + Edge[3,2] 
+      @single.size.should == 4
+      @single.num_edges.should == 3
+      result.size.should == 4
+      result.num_edges.should == 3
+
+      result = @single + 5
+      @single.size.should == 4
+      @single.num_edges.should == 3
+      result.size.should == 5
+      result.num_edges.should == 3
+
+      result = @single - Edge[4,4]
+      @single.size.should == 4
+      @single.num_edges.should == 3
+      result.size.should == 4
+      result.num_edges.should == 3
+
+      result = @single - 4
+      @single.size.should == 4
+      @single.num_edges.should == 3
+      result.size.should == 3
+      result.num_edges.should == 2
+      
+      @single << Edge[6,1]
+      @single.size.should == 5
+      @single.num_edges.should == 4
+      @single.should be_edge(6,1)
+    end
+  end
+
+  describe "complement" do
+    it do
+      complement = @single.complement 
+      complement.vertices.sort.should == [1,2,3,4]
+      complement.should_not be_edge(1,1)
+      complement.should be_edge(1,3)
+      complement.should be_edge(1,4)
+      complement.should_not be_edge(2,2)
+      complement.should be_edge(2,4)
+      complement.should be_edge(3,1)
+      complement.should_not be_edge(3,3)
+      complement.should be_edge(4,1)
+      complement.should be_edge(4,2)
+      ##
+      # This assertion wasn't running correctly in GRATR (`assert`
+      # when it should have been `assert_equal`), failing now, and
+      # may not be valid.
+      # complement.num_edges.should == 7
+    end
+  end
+
+  describe "induced_subgraph" do
+    it do
+      induced = @single.induced_subgraph([1,2])
+      induced.vertices.sort.should == [1,2]
+      induced.should be_edge(1,2)
+       induced.num_edges.should == 1
+    end
+  end
+
+  describe "include" do
+    it do
+      @single.should include(4)
+      @dups.should include(4)
+      @dups.should_not include(5)
+      @single.should_not include(5)
+      @single.should include(Edge[1,2])
+      @dups.should include(Edge[1,2])
+    end
+  end
+
+  describe "adjacent" do
+    it do
+
+      @single.should be_adjacent(2, Edge[1,2])
+      @single.adjacent(1).should == [2]
+
+      @single.adjacent(1, :type=>:edges).should == [Edge[1,2]]
+      @single.adjacent(1, :type=>:edges, :direction=> :out).should == [Edge[1,2]]
+      @single.adjacent(2, :type=>:edges, :direction=> :in).sort.should == [Edge[1,2],Edge[2,3]]
+      @single.adjacent(2, :type=>:edges, :direction=> :all).sort.should == [Edge[1,2],Edge[2,3]]
+
+      @dups.adjacent(1, :type=>:edges).should == [MultiEdge[1,2]]*2
+      @dups.adjacent(1, :type=>:edges, :direction=> :out).should == [MultiEdge[1,2]]*2
+      @dups.adjacent(2, :type=>:edges, :direction=> :in).sort.should == ([MultiEdge[1,2]]*2 + [MultiEdge[2,3]]*2)
+      @dups.adjacent(2, :type=>:edges, :direction=> :all).sort.should == ([MultiEdge[1,2]]*2 + [MultiEdge[2,3]]*2)
+
+      @single.adjacent(1, :type=>:vertices).should == [2]
+      @single.adjacent(1, :type=>:vertices, :direction=> :out).should == [2]
+      @single.adjacent(2, :type=>:vertices, :direction=> :in).should == [1,3]
+      @single.adjacent(2, :type=>:vertices, :direction=> :all).should == [1,3]
+
+      @single.adjacent(Edge[2,3], :type=>:vertices).should == [2,3]
+      @single.adjacent(Edge[2,3], :type=>:vertices, :direction=> :out).should == [2,3]
+      @single.adjacent(Edge[2,3], :type=>:vertices, :direction=> :in).should == [2,3]
+      @single.adjacent(Edge[2,3], :type=>:vertices, :direction=> :all).should == [2,3]
+
+      @single.adjacent(Edge[2,3], :type=>:edges).sort.should == [Edge[1,2],Edge[3,4]]
+      @single.adjacent(Edge[2,3], :type=>:edges, :direction=> :out).sort.should == [Edge[1,2],Edge[3,4]]
+      @single.adjacent(Edge[2,3], :type=>:edges, :direction=> :in).sort.should == [Edge[1,2],Edge[3,4]]
+      @single.adjacent(Edge[2,3], :type=>:edges, :direction=> :all).sort.should == [Edge[1,2],Edge[3,4]]
+      @dups.adjacent(MultiEdge[2,3], :type=>:edges).sort.should == ([MultiEdge[1,2]]*2 + [MultiEdge[3,4]])
+      @dups.adjacent(MultiEdge[2,3], :type=>:edges, :direction=>:out).sort.should == ([MultiEdge[1,2]]*2 + [MultiEdge[3,4]])
+      @dups.adjacent(MultiEdge[2,3], :type=>:edges, :direction=>:in).sort.should == ([MultiEdge[1,2]]*2 + [MultiEdge[3,4]])
+      @dups.adjacent(MultiEdge[2,3], :type=>:edges, :direction=> :all).sort.should == ([MultiEdge[1,2]]*2+[MultiEdge[3,4]])
+    end
+
+    describe "neighborhood" do
+      it do
+        @single.neighborhood(1).sort.should == [2]
+        @single.neighborhood(2).sort.should == [1, 3]
+        @single.neighborhood(Edge[2,3]).sort.should == [Edge[1,2], Edge[3,4]]
+      end
+    end
+
+    describe "degree" do
+      it do
+        @single.in_degree(1).should == 1
+        @single.in_degree(2).should == 2
+        @single.in_degree(4).should == 1
+        @single.out_degree(1).should == 1
+        @single.out_degree(2).should == 2
+        @single.out_degree(4).should == 1
+        @single.add_vertex!(6).out_degree(6).should == 0
+        @single.add_vertex!(7).in_degree(7).should == 0
+        @single.add_edge!(4,2).out_degree(4).should == 2
+        @single.in_degree(2).should == 3
+      end
+    end
+
+    describe "include" do
+      it do
+        @single.should include(2)
+        @single.should_not include(23)
+        @single.should include(Edge[1,2])
+        @single.should_not include(Edge[1,4])
+      end
+    end
+
+  end
+
+end