kanwei-algorithms 0.2.0

data/spec/deque_gc_mark_spec.rb

@@ -0,0 +1,18 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+if defined? Containers::CDeque
+  describe "CDeque" do
+    it "should mark ruby object references" do
+      anon_class = Class.new
+      @deque = Containers::CDeque.new
+      100.times { @deque.push_front(anon_class.new) }
+      # Mark and sweep
+      ObjectSpace.garbage_collect
+      # Check if any instances were swept
+      count = 0
+      ObjectSpace.each_object(anon_class) { |x| count += 1 }
+      count.should eql(100)
+    end
+  end
+end

data/spec/deque_spec.rb

@@ -0,0 +1,108 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+describe "(empty deque)", :shared => true do
+  it "should return nil when popping objects" do
+    @deque.pop_front.should be_nil
+    @deque.pop_back.should be_nil
+  end
+
+  it "should return a size of 1 when sent #push_front" do
+    @deque.push_front(1)
+    @deque.size.should eql(1)
+  end
+
+  it "should return a size of 1 when sent #push_back" do
+    @deque.push_back(1)
+    @deque.size.should eql(1)
+  end
+
+  it "should return nil when sent #front and #back" do
+    @deque.front.should be_nil
+    @deque.back.should be_nil
+  end
+
+  it "should be empty" do
+    @deque.should be_empty
+  end
+
+  it "should raise ArgumentError if passed more than one argument" do
+    lambda { @deque.class.send("new", Time.now, []) }.should raise_error
+  end
+end
+
+describe "(non-empty deque)", :shared => true do
+  before(:each) do
+    @deque.push_back(10)
+    @deque.push_back("10")
+  end
+
+  it "should return last pushed object with pop_back" do
+    @deque.pop_back.should eql("10")
+    @deque.pop_back.should eql(10)
+  end
+
+  it "should return first pushed object with pop_front" do
+    @deque.pop_front.should eql(10)
+    @deque.pop_front.should eql("10")
+  end
+
+  it "should return a size greater than 0" do
+    @deque.size.should eql(2)
+  end
+
+  it "should not be empty" do
+    @deque.should_not be_empty
+  end
+
+  it "should iterate in LIFO order with #each_backward" do
+    arr = []
+    @deque.each_backward { |obj| arr << obj }
+    arr.should eql(["10", 10])
+  end
+
+  it "should iterate in FIFO order with #each_forward" do
+    arr = []
+    @deque.each_forward { |obj| arr << obj }
+    arr.should eql([10, "10"])
+  end
+
+  it "should return nil after everything's popped" do
+    @deque.pop_back
+    @deque.pop_back
+    @deque.pop_back.should be_nil
+    @deque.front.should be_nil
+  end
+end
+
+describe "empty rubydeque" do
+  before(:each) do
+    @deque = Containers::RubyDeque.new
+  end
+  it_should_behave_like "(empty deque)"
+end
+
+describe "full rubydeque" do
+  before(:each) do
+    @deque = Containers::RubyDeque.new
+  end
+  it_should_behave_like "(non-empty deque)"
+end
+
+begin
+  Containers::CDeque
+  describe "empty cdeque" do
+    before(:each) do
+      @deque = Containers::CDeque.new
+    end
+    it_should_behave_like "(empty deque)"
+  end
+
+  describe "full cdeque" do
+    before(:each) do
+      @deque = Containers::CDeque.new
+    end
+    it_should_behave_like "(non-empty deque)"
+  end
+rescue Exception
+end

data/spec/heap_spec.rb

@@ -0,0 +1,126 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+describe Containers::Heap do
+  before(:each) do
+    @heap = Containers::MaxHeap.new
+  end
+  
+  it "should not let you merge with non-heaps" do
+    lambda { @heap.merge!(nil) }.should raise_error
+    lambda { @heap.merge!([]) }.should raise_error
+  end
+  
+  describe "(empty)" do
+  
+    it "should return nil when getting the maximum" do
+      @heap.max!.should be_nil
+    end
+    
+    it "should let you insert and remove one item" do
+      @heap.size.should eql(0)
+      
+      @heap.push(1)
+      @heap.size.should eql(1)
+      
+      @heap.max!.should eql(1)
+      @heap.size.should eql(0)
+    end
+    
+    it "should let you initialize with an array" do
+      @heap = Containers::MaxHeap.new([1,2,3])
+      @heap.size.should eql(3)
+    end
+
+  end
+  
+  describe "(non-empty)" do
+    before(:each) do
+      @random_array = []
+      @num_items = 100
+      @num_items.times { |x| @random_array << rand(@num_items) }
+      @heap = Containers::MaxHeap.new(@random_array)
+    end
+    
+    it "should display the correct size" do
+      @heap.size.should eql(@num_items)
+    end
+    
+    it "should delete random keys" do
+      @heap.delete(@random_array[0]).should eql(@random_array[0])
+      @heap.delete(@random_array[1]).should eql(@random_array[1])
+      ordered = []
+      ordered << @heap.max! until @heap.empty?
+      ordered.should eql( @random_array[2..-1].sort.reverse )
+    end
+    
+    it "should delete all keys" do
+      ordered = []
+      @random_array.size.times do |t|
+        ordered << @heap.delete(@random_array[t])
+      end
+      @heap.should be_empty
+      ordered.should eql( @random_array )
+    end
+
+    it "should be in max->min order" do
+      ordered = []
+      ordered << @heap.max! until @heap.empty?
+      
+      ordered.should eql(@random_array.sort.reverse)
+    end
+    
+    it "should change certain keys" do
+      numbers = [1,2,3,4,5,6,7,8,9,10,100,101]
+      heap = Containers::MinHeap.new(numbers)
+      heap.change_key(101, 50)
+      heap.pop
+      heap.pop
+      heap.change_key(8, 0)
+      ordered = []
+      ordered << heap.min! until heap.empty?
+      ordered.should eql( [8,3,4,5,6,7,9,10,101,100] )
+    end
+    
+    it "should not delete keys it doesn't have" do
+      @heap.delete(:nonexisting).should be_nil
+      @heap.size.should eql(@num_items)
+    end
+    
+    it "should delete certain keys" do
+      numbers = [1,2,3,4,5,6,7,8,9,10,100,101]
+      heap = Containers::MinHeap.new(numbers)
+      heap.delete(5)
+      heap.pop
+      heap.pop
+      heap.delete(100)
+      ordered = []
+      ordered << heap.min! until heap.empty?
+      ordered.should eql( [3,4,6,7,8,9,10,101] )
+    end
+    
+    it "should let you merge with another heap" do
+      numbers = [1,2,3,4,5,6,7,8]
+      otherheap = Containers::MaxHeap.new(numbers)
+      otherheap.size.should eql(8)
+      @heap.merge!(otherheap)
+      
+      ordered = []
+      ordered << @heap.max! until @heap.empty?
+      
+      ordered.should eql( (@random_array + numbers).sort.reverse)
+    end
+    
+    describe "min-heap" do
+      it "should be in min->max order" do
+        @heap = Containers::MinHeap.new(@random_array)
+        ordered = []
+        ordered << @heap.min! until @heap.empty?
+    
+        ordered.should eql(@random_array.sort)
+      end
+    end
+    
+  end
+  
+end

data/spec/kd_tree_spec.rb

@@ -0,0 +1,4 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+# TODO: KD Tree Spec

data/spec/priority_queue_spec.rb

@@ -0,0 +1,75 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+describe Containers::PriorityQueue do
+  before(:each) do
+    @q = Containers::PriorityQueue.new
+  end
+  
+  describe "(empty priority queue)" do
+    it "should return 0 for size and be empty" do
+      @q.size.should eql(0)
+      @q.should be_empty
+    end
+    
+    it "should not return anything" do
+      @q.next.should be_nil
+      @q.pop.should be_nil
+      @q.delete(1).should be_nil
+      @q.has_priority?(1).should be_false
+    end
+    
+    it "should give the correct size when adding items" do
+      20.times do |i|
+        @q.size.should eql(i)
+        @q.push(i, i)
+      end
+      10.times do |i|
+        @q.size.should eql(20-i)
+        @q.pop
+      end
+      10.times do |i|
+        @q.size.should eql(i+10)
+        @q.push(i, i)
+      end
+      @q.delete(5)
+      @q.size.should eql(19)
+    end
+  end
+  
+  describe "(non-empty priority queue)" do
+    before(:each) do
+      @q.push("Alaska", 50)
+      @q.push("Delaware", 30)
+      @q.push("Georgia", 35)
+    end
+    
+    it "should next/pop the highest priority" do
+      @q.next.should eql("Alaska")
+      @q.size.should eql(3)
+      @q.pop.should eql("Alaska")
+      @q.size.should eql(2)
+    end
+    
+    it "should not be empty" do
+      @q.should_not be_empty
+    end
+    
+    it "should has_priority? priorities it has" do
+      @q.has_priority?(50).should be_true
+      @q.has_priority?(10).should be_false
+    end      
+    
+    it "should return nil after popping everything" do
+      3.times do 
+        @q.pop
+      end
+      @q.pop.should be_nil
+    end
+    
+    it "should delete things it has and not things it doesn't" do
+      @q.delete(50).should eql("Alaska")
+      @q.delete(10).should eql(nil)
+    end
+  end
+end

data/spec/queue_spec.rb

@@ -0,0 +1,61 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+describe "empty queue" do
+  before(:each) do
+    @queue = Containers::Queue.new
+  end
+
+
+  it "should return nil when sent #pop" do
+    @queue.pop.should be_nil
+  end
+
+  it "should return a size of 1 when sent #push" do
+    @queue.push(1)
+    @queue.size.should eql(1)
+  end
+
+  it "should return nil when sent #next" do
+    @queue.next.should be_nil
+  end
+
+  it "should return empty?" do
+    @queue.empty?.should be_true
+  end
+end
+
+describe "non-empty queue" do
+  before(:each) do
+    @queue = Containers::Queue.new
+    @queue.push(10)
+    @queue.push("10")
+  end
+
+  it "should return first pushed object" do
+    @queue.pop.should eql(10)
+  end
+
+  it "should return the size" do
+    @queue.size.should eql(2)
+  end
+
+  it "should not return empty?" do
+    @queue.empty?.should be_false
+  end
+
+  it "should iterate in FIFO order" do
+    arr = []
+    @queue.each { |obj| arr << obj }
+    arr.should eql([10, "10"])
+  end
+
+  it "should return nil after all gets" do
+    2.times do
+      @queue.pop
+    end
+    @queue.pop.should be_nil
+    @queue.next.should be_nil
+  end
+
+end

data/spec/rb_tree_map_gc_mark_spec.rb

@@ -0,0 +1,25 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+if defined? Containers::CRBTreeMap
+  describe "CRBTreeMap" do
+    it "should mark ruby object references" do
+      anon_key_class = Class.new do
+        attr :value
+        def initialize(x); @value = x; end
+        def <=>(other); value <=> other.value; end
+      end
+      anon_val_class = Class.new
+      @tree = Containers::CRBTreeMap.new
+      100.times { |x| @tree[anon_key_class.new(x)] = anon_val_class.new }
+      # Mark and sweep
+      ObjectSpace.garbage_collect
+      # Check if any instances were swept
+      count = 0
+      ObjectSpace.each_object(anon_key_class) { |x| count += 1 }
+      count.should eql(100)
+      ObjectSpace.each_object(anon_val_class) { |x| count += 1 }
+      count.should eql(200)
+    end
+  end
+end

data/spec/rb_tree_map_spec.rb

@@ -0,0 +1,123 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+describe "empty rbtree", :shared => true do
+  it "should let you push stuff in" do
+    100.times { |x| @tree[x] = x }
+    @tree.size.should eql(100)
+  end
+
+  it "should be empty?" do
+    @tree.empty?.should be_true
+  end
+
+  it "should return 0 for height" do
+    @tree.height.should eql(0)
+  end
+
+  it "should return 0 for size" do
+    @tree.size.should eql(0)
+  end
+
+  it "should return nil for max and min" do
+    @tree.min.should be_nil
+    @tree.max.should be_nil
+    @tree.min_key.should be_nil
+    @tree.max_key.should be_nil
+  end
+
+  it "should not delete" do
+    @tree.delete(:non_existing).should be_nil
+  end
+end
+
+describe "non-empty rbtree", :shared => true do
+  before(:each) do
+    @num_items = 1000
+    @random_array = Array.new(@num_items) { rand(@num_items) }
+    @random_array.each { |x| @tree[x] = x }
+  end
+
+  it "should return correct size (uniqify items first)" do
+    @tree.should_not be_empty
+    @tree.size.should eql(@random_array.uniq.size)
+  end
+
+  it "should return correct max and min" do
+    @tree.min_key.should eql(@random_array.min)
+    @tree.max_key.should eql(@random_array.max)
+    @tree.min[0].should eql(@random_array.min)
+    @tree.max[0].should eql(@random_array.max)
+  end
+
+  it "should not #has_key? keys it doesn't have" do
+    @tree.has_key?(100000).should be_false
+  end
+
+  it "should #has_key? keys it does have" do
+    @tree.has_key?(@random_array[0]).should be_true
+  end
+
+  it "should remove all keys" do
+    ordered = []
+    @random_array.uniq.each do |key|
+      @tree.has_key?(key).should eql(true)
+      ordered << @tree.delete(key)
+      @tree.has_key?(key).should eql(false)
+    end
+    ordered.should eql(@random_array.uniq)
+  end
+
+  it "should delete_min keys correctly" do
+    ascending = []
+    ascending << @tree.delete_min until @tree.empty?
+    ascending.should eql(@random_array.uniq.sort)
+  end
+
+  it "should delete_max keys correctly" do
+    descending = []
+    descending << @tree.delete_max until @tree.empty?
+    descending.should eql(@random_array.uniq.sort.reverse)
+  end
+
+  it "should let you iterate with #each" do
+    counter = 0
+    sorted_array = @random_array.uniq.sort
+    @tree.each do |key, val|
+      key.should eql(sorted_array[counter])
+      counter += 1
+    end
+  end
+end
+
+describe "empty rbtreemap" do
+  before(:each) do
+    @tree = Containers::RubyRBTreeMap.new
+  end
+  it_should_behave_like "empty rbtree"
+end
+
+describe "full rbtreemap" do
+  before(:each) do
+    @tree = Containers::RubyRBTreeMap.new
+  end
+  it_should_behave_like "non-empty rbtree"
+end
+
+begin
+  Containers::CRBTreeMap
+  describe "empty crbtreemap" do
+    before(:each) do
+      @tree = Containers::CRBTreeMap.new
+    end
+    it_should_behave_like "empty rbtree"
+  end
+
+  describe "full crbtreemap" do
+    before(:each) do
+      @tree = Containers::CRBTreeMap.new
+    end
+    it_should_behave_like "non-empty rbtree"
+  end
+rescue Exception
+end