algorithms 0.5.0 → 1.1.0

data/spec/deque_spec.rb

@@ -3,31 +3,31 @@ require 'algorithms'
 
 shared_examples "(empty deque)" do
   it "should return nil when popping objects" do
-    @deque.pop_front.should be_nil
-    @deque.pop_back.should be_nil
+    expect(@deque.pop_front).to be_nil
+    expect(@deque.pop_back).to be_nil
   end
 
   it "should return a size of 1 when sent #push_front" do
     @deque.push_front(1)
-    @deque.size.should eql(1)
+    expect(@deque.size).to eql(1)
   end
 
   it "should return a size of 1 when sent #push_back" do
     @deque.push_back(1)
-    @deque.size.should eql(1)
+    expect(@deque.size).to eql(1)
   end
 
   it "should return nil when sent #front and #back" do
-    @deque.front.should be_nil
-    @deque.back.should be_nil
+    expect(@deque.front).to be_nil
+    expect(@deque.back).to be_nil
   end
 
   it "should be empty" do
-    @deque.should be_empty
+    expect(@deque).to be_empty
   end
 
   it "should raise ArgumentError if passed more than one argument" do
-    lambda { @deque.class.send("new", Time.now, []) }.should raise_error
+    expect { @deque.class.send("new", Time.now, []) }.to raise_error(ArgumentError)
   end
 end
 
@@ -38,40 +38,40 @@ shared_examples "(non-empty deque)" do
   end
 
   it "should return last pushed object with pop_back" do
-    @deque.pop_back.should eql("10")
-    @deque.pop_back.should eql(10)
+    expect(@deque.pop_back).to eql("10")
+    expect(@deque.pop_back).to 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")
+    expect(@deque.pop_front).to eql(10)
+    expect(@deque.pop_front).to eql("10")
   end
 
   it "should return a size greater than 0" do
-    @deque.size.should eql(2)
+    expect(@deque.size).to eql(2)
   end
 
   it "should not be empty" do
-    @deque.should_not be_empty
+    expect(@deque).not_to 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])
+    expect(arr).to 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"])
+    expect(arr).to 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
+    expect(@deque.pop_back).to be_nil
+    expect(@deque.front).to be_nil
   end
 end
 

data/spec/heap_spec.rb

@@ -1,35 +1,221 @@
 $: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
 require 'algorithms'
 
+include Comparable
+
+class Book
+  attr_reader :title, :year_published
+
+  def initialize(title, year_published)
+    @title = title
+    @year_published = year_published
+  end
+
+  def <=>(other)
+    return nil unless other.is_a?(Book)
+
+    # 1. Compare by year first
+    year_comparison = self.year_published <=> other.year_published
+
+    # 2. If years are different, return that comparison result
+    return year_comparison unless year_comparison == 0
+
+    # 3. If years are the same (tie), compare by title alphabetically
+    #    (Ensure title comparison returns -1, 0, or 1)
+    self.title <=> other.title
+  end
+
+
+  def to_s
+    "\"#{title}\" (#{year_published})" # Simplified for test output
+  end
+
+  # Add an equality method for clearer test failures if needed,
+  # though <=> returning 0 handles equality for sorting/heap purposes.
+  def ==(other)
+    other.is_a?(Book) &&
+      self.title == other.title &&
+      self.year_published == other.year_published
+  end
+  alias eql? ==
+
+  def hash
+    [title, year_published].hash
+  end
+
+end
+
+describe ::Containers::Heap do
+
+  # --- Test Data Setup ---
+  let!(:book_1932) { Book.new("Brave New World", 1932) }
+  let!(:book_1949) { Book.new("1984", 1949) }
+  let!(:book_1951a) { Book.new("Foundation", 1951) }
+  # Add another book from the same year to test handling of equal priority items
+  let!(:book_1951b) { Book.new("The Illustrated Man", 1951) }
+  let!(:book_1965) { Book.new("Dune", 1965) }
+  let!(:book_1989) { Book.new("Hyperion", 1989) }
+
+  # Use shuffle to ensure tests don't depend on insertion order
+  let(:books) { [book_1965, book_1951a, book_1989, book_1949, book_1932, book_1951b].shuffle }
+
+  let(:expected_min_order) { books.sort }
+
+  let(:expected_max_order) { books.sort.reverse }
+
+  context "Min-Heap (using default <=> via Comparable)" do
+    # Initialize heap with books; it should use Book#<=> by default
+    let(:min_heap) { ::Containers::Heap.new(books) }
+
+    it "initializes with the correct size" do
+      expect(min_heap.size).to eq(books.size)
+      expect(min_heap.empty?).to be false
+    end
+
+    it "gets the next minimum element (earliest year) without removing it" do
+      # next should return the element with the smallest year_published
+      expect(min_heap.next).to eq(book_1932)
+      # next should not change the size
+      expect(min_heap.size).to eq(books.size)
+    end
+
+    it "pops elements in ascending order of year_published" do
+      popped_books = []
+      while (book = min_heap.pop)
+        popped_books << book
+      end
+
+      # Verify the popped order matches the expected sorted order
+      expect(popped_books).to eq(expected_min_order)
+
+      # Verify the heap is now empty
+      expect(min_heap.size).to eq(0)
+      expect(min_heap.empty?).to be true
+      expect(min_heap.pop).to be_nil # Popping an empty heap
+      expect(min_heap.next).to be_nil # Getting next from an empty heap
+    end
+
+    it "correctly updates size after popping" do
+       expect(min_heap.size).to eq(books.size)
+       min_heap.pop
+       expect(min_heap.size).to eq(books.size - 1)
+    end
+  end
+
+
+  context "Max-Heap (using a custom comparison block)" do
+    # Initialize heap with books and a block for max-heap behavior
+    # The block returns true if x should have higher priority (be "larger") than y
+    let(:max_heap) { ::Containers::Heap.new(books) { |x, y| x > y } } # Use > from Comparable
+
+    it "initializes with the correct size" do
+      expect(max_heap.size).to eq(books.size)
+      expect(max_heap.empty?).to be false
+    end
+
+    it "gets the next maximum element (latest year) without removing it" do
+      # next should return the element with the largest year_published
+      expect(max_heap.next).to eq(book_1989)
+      # next should not change the size
+      expect(max_heap.size).to eq(books.size)
+    end
+
+    it "pops elements in descending order of year_published" do
+      popped_books = []
+      while (book = max_heap.pop)
+        popped_books << book
+      end
+
+      # Verify the popped order matches the expected reversed sorted order
+      expect(popped_books).to eq(expected_max_order)
+
+      # Verify the heap is now empty
+      expect(max_heap.size).to eq(0)
+      expect(max_heap.empty?).to be true
+      expect(max_heap.pop).to be_nil # Popping an empty heap
+      expect(max_heap.next).to be_nil # Getting next from an empty heap
+    end
+
+     it "correctly updates size after popping" do
+       expect(max_heap.size).to eq(books.size)
+       max_heap.pop
+       expect(max_heap.size).to eq(books.size - 1)
+    end
+  end
+
+  context "Edge cases" do
+    it "handles an empty initialization" do
+      heap = ::Containers::Heap.new([])
+      expect(heap.size).to eq(0)
+      expect(heap.empty?).to be true
+      expect(heap.pop).to be_nil
+      expect(heap.next).to be_nil
+    end
+
+    it "handles initialization with one element" do
+      heap = ::Containers::Heap.new([book_1965])
+      expect(heap.size).to eq(1)
+      expect(heap.next).to eq(book_1965)
+      expect(heap.pop).to eq(book_1965)
+      expect(heap.empty?).to be true
+    end
+  end
+
+end
+
 describe Containers::Heap do
   before(:each) do
     @heap = Containers::MaxHeap.new
   end
+
+  it "should run without error when given Objects and a non-ordering comparator" do
+    # Create and store the initial distinct objects
+    initial_objects = 10.times.map { Object.new }
+    initial_object_ids = initial_objects.map(&:object_id) # Store IDs for comparison
+
+    min_heap = ::Containers::Heap.new(initial_objects) { |x, y| (x <=> y) == -1 }
+
+    expect(min_heap.size).to eq(10)
+
+    popped_elements = []
+    expect {
+      while val = min_heap.pop do
+        popped_elements << val
+      end
+    }.not_to raise_error
+
+    expect(min_heap.empty?).to be true
+    expect(popped_elements.size).to eq(10)
+
+    # Assert that exactly the same objects were returned, regardless of order.
+    # Comparing by object_id is the most reliable way for distinct Objects.
+    expect(popped_elements.map(&:object_id)).to contain_exactly(*initial_object_ids)
+  end
   
   it "should not let you merge with non-heaps" do
-    lambda { @heap.merge!(nil) }.should raise_error
-    lambda { @heap.merge!([]) }.should raise_error
+    expect { @heap.merge!(nil) }.to raise_error(ArgumentError)
+    expect { @heap.merge!([]) }.to raise_error(ArgumentError)
   end
   
   describe "(empty)" do
   
     it "should return nil when getting the maximum" do
-      @heap.max!.should be_nil
+      expect(@heap.max!).to be_nil
     end
     
     it "should let you insert and remove one item" do
-      @heap.size.should eql(0)
+      expect(@heap.size).to eql(0)
       
       @heap.push(1)
-      @heap.size.should eql(1)
+      expect(@heap.size).to eql(1)
       
-      @heap.max!.should eql(1)
-      @heap.size.should eql(0)
+      expect(@heap.max!).to eql(1)
+      expect(@heap.size).to eql(0)
     end
     
     it "should let you initialize with an array" do
       @heap = Containers::MaxHeap.new([1,2,3])
-      @heap.size.should eql(3)
+      expect(@heap.size).to eql(3)
     end
 
   end
@@ -38,25 +224,25 @@ describe Containers::Heap do
     before(:each) do
       @random_array = []
       @num_items = 100
-      @num_items.times { |x| @random_array << rand(@num_items) }
+      @num_items.times { @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)
+      expect(@heap.size).to eql(@num_items)
     end
     
     it "should have a next value" do
-      @heap.next.should be_true
-      @heap.next_key.should be_true
+      expect(@heap.next).to be_truthy
+      expect(@heap.next_key).to be_truthy
     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])
+      expect(@heap.delete(@random_array[0])).to eql(@random_array[0])
+      expect(@heap.delete(@random_array[1])).to eql(@random_array[1])
       ordered = []
       ordered << @heap.max! until @heap.empty?
-      ordered.should eql( @random_array[2..-1].sort.reverse )
+      expect(ordered).to eql( @random_array[2..-1].sort.reverse )
     end
     
     it "should delete all keys" do
@@ -64,15 +250,15 @@ describe Containers::Heap do
       @random_array.size.times do |t|
         ordered << @heap.delete(@random_array[t])
       end
-      @heap.should be_empty
-      ordered.should eql( @random_array )
+      expect(@heap).to be_empty
+      expect(ordered).to 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)
+      expect(ordered).to eql(@random_array.sort.reverse)
     end
     
     it "should change certain keys" do
@@ -84,12 +270,12 @@ describe Containers::Heap do
       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] )
+      expect(ordered).to 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)
+      expect(@heap.delete(:nonexisting)).to be_nil
+      expect(@heap.size).to eql(@num_items)
     end
     
     it "should delete certain keys" do
@@ -101,19 +287,19 @@ describe Containers::Heap do
       heap.delete(100)
       ordered = []
       ordered << heap.min! until heap.empty?
-      ordered.should eql( [3,4,6,7,8,9,10,101] )
+      expect(ordered).to 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)
+      expect(otherheap.size).to eql(8)
       @heap.merge!(otherheap)
       
       ordered = []
       ordered << @heap.max! until @heap.empty?
       
-      ordered.should eql( (@random_array + numbers).sort.reverse)
+      expect(ordered).to eql( (@random_array + numbers).sort.reverse)
     end
     
     describe "min-heap" do
@@ -122,7 +308,7 @@ describe Containers::Heap do
         ordered = []
         ordered << @heap.min! until @heap.empty?
     
-        ordered.should eql(@random_array.sort)
+        expect(ordered).to eql(@random_array.sort)
       end
     end
     

data/spec/kd_tree_spec.rb

@@ -6,7 +6,7 @@ describe Containers::KDTree 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)
-    closest_2.should eql([[5, 2], [9, 1]])
+    expect(closest_2).to eql([[5, 2], [9, 1]])
   end
   
   it "should work for real-life example from facebook puzzle" do
@@ -28,7 +28,7 @@ describe Containers::KDTree do
     }
     
     expected = File.read(File.join(File.dirname(__FILE__), 'kd_expected_out.txt'))
-    expected.should eql(out)
+    expect(expected).to eql(out)
   end
   
 end

data/spec/map_gc_mark_spec.rb

@@ -1,27 +1,29 @@
 $: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
 require 'algorithms'
 
-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
+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
-    anon_val_class = Class.new
-    @rbtree = Containers::CRBTreeMap.new
-    @splaytree = Containers::CSplayTreeMap.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 }
-    count.should eql(200)
-    ObjectSpace.each_object(anon_val_class) { |x| count += 1 }
-    count.should eql(400)
   end
 end

data/spec/priority_queue_spec.rb

@@ -8,32 +8,32 @@ describe Containers::PriorityQueue do
   
   describe "(empty priority queue)" do
     it "should return 0 for size and be empty" do
-      @q.size.should eql(0)
-      @q.should be_empty
+      expect(@q.size).to eql(0)
+      expect(@q).to 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
+      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|
-        @q.size.should eql(i)
+        expect(@q.size).to eql(i)
         @q.push(i, i)
       end
       10.times do |i|
-        @q.size.should eql(20-i)
+        expect(@q.size).to eql(20-i)
         @q.pop
       end
       10.times do |i|
-        @q.size.should eql(i+10)
+        expect(@q.size).to eql(i+10)
         @q.push(i, i)
       end
       @q.delete(5)
-      @q.size.should eql(19)
+      expect(@q.size).to eql(19)
     end
   end
   
@@ -45,31 +45,31 @@ describe Containers::PriorityQueue do
     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)
+      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
-      @q.should_not be_empty
+      expect(@q).not_to 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
+      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
-      @q.pop.should be_nil
+      expect(@q.pop).to 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)
+      expect(@q.delete(50)).to eql("Alaska")
+      expect(@q.delete(10)).to eql(nil)
     end
   end
 end

data/spec/queue_spec.rb

@@ -8,20 +8,20 @@ describe "empty queue" do
 
 
   it "should return nil when sent #pop" do
-    @queue.pop.should be_nil
+    expect(@queue.pop).to be_nil
   end
 
   it "should return a size of 1 when sent #push" do
     @queue.push(1)
-    @queue.size.should eql(1)
+    expect(@queue.size).to eql(1)
   end
 
   it "should return nil when sent #next" do
-    @queue.next.should be_nil
+    expect(@queue.next).to be_nil
   end
 
   it "should return empty?" do
-    @queue.empty?.should be_true
+    expect(@queue.empty?).to be true
   end
 end
 
@@ -33,29 +33,29 @@ describe "non-empty queue" do
   end
 
   it "should return first pushed object" do
-    @queue.pop.should eql(10)
+    expect(@queue.pop).to eql(10)
   end
 
   it "should return the size" do
-    @queue.size.should eql(2)
+    expect(@queue.size).to eql(2)
   end
 
   it "should not return empty?" do
-    @queue.empty?.should be_false
+    expect(@queue.empty?).to be false
   end
 
   it "should iterate in FIFO order" do
     arr = []
     @queue.each { |obj| arr << obj }
-    arr.should eql([10, "10"])
+    expect(arr).to 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
+    expect(@queue.pop).to be_nil
+    expect(@queue.next).to be_nil
   end
 
 end