amorim-algorithms 0.6.1

data/spec/kd_tree_spec.rb

@@ -0,0 +1,34 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+describe Containers::KDTree do
+  it "should work for a documented example" do
+    kdtree = Containers::KDTree.new( {0 => [4, 3], 1 => [3, 0], 2 => [-1, 2], 3 => [6, 4],
+                                     4 => [3, -5], 5 => [-2, -5] })
+    closest_2 = kdtree.find_nearest([0, 0], 2)
+    expect(closest_2).to eql([[5, 2], [9, 1]])
+  end
+  
+  it "should work for real-life example from facebook puzzle" do
+    points = {}
+    input = File.open(File.join(File.dirname(__FILE__), 'kd_test_in.txt'), 'r')
+
+    # Populate points hash
+    input.each_line do |line|
+      break if line.empty?
+      n, x, y = line.split(/\s+/)
+      points[n.to_i] = [x.to_f, y.to_f]
+    end
+
+    out = ""
+    kdtree = Containers::KDTree.new(points)
+    points.sort{ |(k1, v1), (k2, v2)| k1 <=> k2 }.each { |id, point|
+      nearest_4 = kdtree.find_nearest(point, 4)
+      out << "#{id} #{nearest_4[1..-1].collect{ |n| n[1] }.join(',')}\n"
+    }
+    
+    expected = File.read(File.join(File.dirname(__FILE__), 'kd_expected_out.txt'))
+    expect(expected).to eql(out)
+  end
+  
+end

data/spec/map_gc_mark_spec.rb

@@ -0,0 +1,29 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+if !(defined? RUBY_ENGINE && RUBY_ENGINE == 'jruby')
+  describe "map gc mark test" 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
+      @rbtree = Containers::RBTreeMap.new
+      @splaytree = Containers::SplayTreeMap.new
+      100.times { |x| 
+        @rbtree[anon_key_class.new(x)] = anon_val_class.new
+        @splaytree[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 }
+      expect(count).to eql(200)
+      ObjectSpace.each_object(anon_val_class) { |x| count += 1 }
+      expect(count).to eql(400)
+    end
+  end
+end

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
+      expect(@q.size).to eql(0)
+      expect(@q).to be_empty
+    end
+    
+    it "should not return anything" do
+      expect(@q.next).to be_nil
+      expect(@q.pop).to be_nil
+      expect(@q.delete(1)).to be_nil
+      expect(@q.has_priority?(1)).to be false
+    end
+    
+    it "should give the correct size when adding items" do
+      20.times do |i|
+        expect(@q.size).to eql(i)
+        @q.push(i, i)
+      end
+      10.times do |i|
+        expect(@q.size).to eql(20-i)
+        @q.pop
+      end
+      10.times do |i|
+        expect(@q.size).to eql(i+10)
+        @q.push(i, i)
+      end
+      @q.delete(5)
+      expect(@q.size).to 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
+      expect(@q.next).to eql("Alaska")
+      expect(@q.size).to eql(3)
+      expect(@q.pop).to eql("Alaska")
+      expect(@q.size).to eql(2)
+    end
+    
+    it "should not be empty" do
+      expect(@q).not_to be_empty
+    end
+    
+    it "should has_priority? priorities it has" do
+      expect(@q.has_priority?(50)).to be true
+      expect(@q.has_priority?(10)).to be false
+    end      
+    
+    it "should return nil after popping everything" do
+      3.times do 
+        @q.pop
+      end
+      expect(@q.pop).to be_nil
+    end
+    
+    it "should delete things it has and not things it doesn't" do
+      expect(@q.delete(50)).to eql("Alaska")
+      expect(@q.delete(10)).to 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
+    expect(@queue.pop).to be_nil
+  end
+
+  it "should return a size of 1 when sent #push" do
+    @queue.push(1)
+    expect(@queue.size).to eql(1)
+  end
+
+  it "should return nil when sent #next" do
+    expect(@queue.next).to be_nil
+  end
+
+  it "should return empty?" do
+    expect(@queue.empty?).to 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
+    expect(@queue.pop).to eql(10)
+  end
+
+  it "should return the size" do
+    expect(@queue.size).to eql(2)
+  end
+
+  it "should not return empty?" do
+    expect(@queue.empty?).to be false
+  end
+
+  it "should iterate in FIFO order" do
+    arr = []
+    @queue.each { |obj| arr << obj }
+    expect(arr).to eql([10, "10"])
+  end
+
+  it "should return nil after all gets" do
+    2.times do
+      @queue.pop
+    end
+    expect(@queue.pop).to be_nil
+    expect(@queue.next).to be_nil
+  end
+
+end

data/spec/rb_tree_map_spec.rb

@@ -0,0 +1,123 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+shared_examples "empty rbtree" do
+  it "should let you push stuff in" do
+    100.times { |x| @tree[x] = x }
+    expect(@tree.size).to eql(100)
+  end
+
+  it "should be empty?" do
+    expect(@tree.empty?).to be true
+  end
+
+  it "should return 0 for height" do
+    expect(@tree.height).to eql(0)
+  end
+
+  it "should return 0 for size" do
+    expect(@tree.size).to eql(0)
+  end
+
+  it "should return nil for max and min" do
+    expect(@tree.min).to be_nil
+    expect(@tree.max).to be_nil
+    expect(@tree.min_key).to be_nil
+    expect(@tree.max_key).to be_nil
+  end
+
+  it "should not delete" do
+    expect(@tree.delete(:non_existing)).to be_nil
+  end
+end
+
+shared_examples "non-empty rbtree" 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
+    expect(@tree).not_to be_empty
+    expect(@tree.size).to eql(@random_array.uniq.size)
+  end
+
+  it "should return correct max and min" do
+    expect(@tree.min_key).to eql(@random_array.min)
+    expect(@tree.max_key).to eql(@random_array.max)
+    expect(@tree.min[0]).to eql(@random_array.min)
+    expect(@tree.max[0]).to eql(@random_array.max)
+  end
+
+  it "should not #has_key? keys it doesn't have" do
+    expect(@tree.has_key?(100000)).to be false
+  end
+
+  it "should #has_key? keys it does have" do
+    expect(@tree.has_key?(@random_array[0])).to be true
+  end
+
+  it "should remove all keys" do
+    ordered = []
+    @random_array.uniq.each do |key|
+      expect(@tree.has_key?(key)).to eql(true)
+      ordered << @tree.delete(key)
+      expect(@tree.has_key?(key)).to eql(false)
+    end
+    expect(ordered).to eql(@random_array.uniq)
+  end
+
+  it "should delete_min keys correctly" do
+    ascending = []
+    ascending << @tree.delete_min until @tree.empty?
+    expect(ascending).to eql(@random_array.uniq.sort)
+  end
+
+  it "should delete_max keys correctly" do
+    descending = []
+    descending << @tree.delete_max until @tree.empty?
+    expect(descending).to 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|
+      expect(key).to 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

data/spec/search_spec.rb

@@ -0,0 +1,28 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+class String; include Algorithms::Search; end
+
+describe "search algorithms" do
+  it "should binary search sorted arrays" do
+    n = 1000
+    @rand_array = Array.new(n) { rand(n) }.sort
+    
+    expect(Algorithms::Search.binary_search(@rand_array, @rand_array.first)).to eql(@rand_array.first)
+    expect(Algorithms::Search.binary_search(@rand_array, 999999)).to be_nil
+    expect(Algorithms::Search.binary_search(@rand_array, nil)).to be_nil
+  end
+  
+  it "should use kmp_search to find substrings it has" do
+    string = "ABC ABCDAB ABCDABCDABDE"
+    expect(Algorithms::Search.kmp_search(string, "ABCDABD")).to eql(15)
+    expect(Algorithms::Search.kmp_search(string, "ABCDEF")).to be_nil
+    expect(Algorithms::Search.kmp_search(string, nil)).to be_nil
+    expect(Algorithms::Search.kmp_search(string, "")).to be_nil
+    expect(Algorithms::Search.kmp_search(nil, "ABCD")).to be_nil
+  end
+  
+  it "should let you include Search in String to enable instance methods" do
+    expect("ABC ABCDAB ABCDABCDABDE".kmp_search("ABCDABD")).to eql(15)
+  end
+end

data/spec/sort_spec.rb

@@ -0,0 +1,29 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+include Algorithms
+
+describe "sort algorithms" do
+  before(:each) do
+    @sorts = %w(bubble_sort comb_sort selection_sort heapsort insertion_sort 
+      shell_sort quicksort mergesort dualpivotquicksort)
+  end
+
+  it "should work for empty containers" do
+    empty_array = []
+    @sorts.each { |sort| expect(Sort.send(sort, empty_array)).to eql([]) }
+  end
+
+  it "should work for a container of size 1" do
+    one_array = [1]
+    @sorts.each { |sort| expect(Sort.send(sort, one_array)).to eql([1]) }
+  end
+
+  it "should work for random arrays of numbers" do
+    n = 500
+    rand_array = Array.new(n) { rand(n) }
+    sorted_array = rand_array.sort
+
+    @sorts.each { |sort| expect(Sort.send(sort, rand_array.dup)).to eql(sorted_array) }
+  end    
+
+end

data/spec/splay_tree_map_spec.rb

@@ -0,0 +1,106 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+  
+shared_examples "empty splaytree" do
+  it "should let you push stuff in" do
+    100.times { |x| @tree[x] = x }
+    expect(@tree.size).to eql(100)
+  end
+  
+  it "should return 0 for size" do
+    expect(@tree.size).to eql(0)
+  end
+  
+  it "should return nil for #min and #max" do
+    expect(@tree.min).to be_nil
+    expect(@tree.max).to be_nil
+  end
+  
+  it "should return nil for #delete" do
+    expect(@tree.delete(:non_existing)).to be_nil
+  end
+  
+  it "should return nil for #get" do
+    expect(@tree[4235]).to be_nil
+  end
+end
+
+shared_examples "non-empty splaytree" do
+  before(:each) do
+    @num_items = 100
+    @random_array = []
+    @num_items.times { @random_array << rand(@num_items) }
+    @random_array.each { |x| @tree[x] = x }
+  end
+  
+  it "should return correct size (uniqify items first)" do
+    expect(@tree.size).to eql(@random_array.uniq.size)
+  end
+  
+  it "should have correct height (worst case is when items are inserted in order, and height = num items inserted)" do
+    @tree.clear
+    10.times { |x| @tree[x] = x }
+    expect(@tree.height).to eql(10)
+  end
+  
+  it "should return correct max and min keys" do
+    expect(@tree.min[0]).to eql(@random_array.min)
+    expect(@tree.max[0]).to eql(@random_array.max)
+  end
+  
+  it "should not #has_key? keys it doesn't have" do
+    expect(@tree.has_key?(10000)).to be false
+  end
+  
+  it "should #has_key? keys it does have" do
+    expect(@tree.has_key?(@random_array[0])).to be true
+  end
+  
+  it "should remove any key" do
+    random_key = @random_array[rand(@num_items)]
+    expect(@tree.has_key?(random_key)).to be true
+    expect(@tree.delete(random_key)).to eql(random_key)
+    expect(@tree.has_key?(random_key)).to be false
+  end
+  
+  it "should let you iterate with #each" do
+    counter = 0
+    sorted_array = @random_array.uniq.sort
+    @tree.each do |key, val|
+      expect(key).to eql(sorted_array[counter])
+      counter += 1
+    end
+  end
+end
+
+describe "empty splaytreemap" do
+  before(:each) do
+    @tree = Containers::RubySplayTreeMap.new
+  end
+  it_should_behave_like "empty splaytree"
+end
+
+describe "full splaytreemap" do
+  before(:each) do
+    @tree = Containers::RubySplayTreeMap.new
+  end
+  it_should_behave_like "non-empty splaytree"
+end
+
+begin
+  Containers::CSplayTreeMap
+  describe "empty csplaytreemap" do
+    before(:each) do
+      @tree = Containers::CSplayTreeMap.new
+    end
+    it_should_behave_like "empty splaytree"
+  end
+
+  describe "full csplaytreemap" do
+    before(:each) do
+      @tree = Containers::CSplayTreeMap.new
+    end
+    it_should_behave_like "non-empty splaytree"
+  end
+rescue Exception
+end