jumoku 0.2.0 → 0.2.1

data/vendor/git/plexus/spec/spec.opts

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

data/vendor/git/plexus/spec/spec_helper.rb

@@ -1,59 +0,0 @@
-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/vendor/git/plexus/spec/strong_components_spec.rb

@@ -1,61 +0,0 @@
-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/vendor/git/plexus/spec/triangulated_spec.rb

@@ -1,125 +0,0 @@
-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/vendor/git/plexus/spec/undirected_graph_spec.rb

@@ -1,220 +0,0 @@
-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