algorithms 0.2.0 → 1.0.0

data/lib/algorithms.rb

@@ -29,6 +29,7 @@
   * Splay Trees     - Containers::SplayTreeMap
   * Tries           - Containers::Trie
   * Suffix Array    - Containers::SuffixArray
+  * kd Tree         - Containers::KDTree
 
   * Search algorithms
     - Binary Search         - Algorithms::Search.binary_search
@@ -42,19 +43,17 @@
     - Shell sort            - Algorithms::Sort.shell_sort
     - Quicksort             - Algorithms::Sort.quicksort
     - Mergesort             - Algorithms::Sort.mergesort
+    - Dual-Pivot Quicksort  - Algorithms::Sort.dualpivotquicksort
+  * String algorithms
+    - Levenshtein distance  - Algorithms::String.levenshtein_dist
 =end
 
 module Algorithms; end
 module Containers; end
 
-begin
-  require 'CBst'
-  Containers::Bst = Containers::CBst
-rescue LoadError # C Version could not be found
-end
-
 require 'algorithms/search'
 require 'algorithms/sort'
+require 'algorithms/string'
 require 'containers/heap'
 require 'containers/stack'
 require 'containers/deque'

data/lib/algorithms/sort.rb

@@ -235,4 +235,134 @@ module Algorithms::Sort
     sorted + left + right
   end
 
+  # Dual-Pivot Quicksort is a variation of Quicksort by Vladimir Yaroslavskiy.
+  # This is an implementation of the algorithm as it was found in the original
+  # research paper:
+  # 
+  # http://iaroslavski.narod.ru/quicksort/DualPivotQuicksort.pdf
+  # 
+  # Mirror:
+  # http://codeblab.com/wp-content/uploads/2009/09/DualPivotQuicksort.pdf
+  #
+  # "This algorithm offers O(n log(n)) performance on many data sets that cause
+  # other quicksorts to degrade to quadratic performance, and is typically 
+  # faster than traditional (one-pivot) Quicksort implementations."
+  #   -- http://download.oracle.com/javase/7/docs/api/java/util/Arrays.html
+  #
+  # The algorithm was improved by Vladimir Yaroslavskiy, Jon Bentley, and 
+  # Joshua Bloch, and was implemented as the default sort algorithm for
+  # primatives in Java 7.
+  #
+  # Implementation in the Java JDK as of November, 2011:
+  # http://www.docjar.com/html/api/java/util/DualPivotQuicksort.java.html
+  #
+  # It is proved that for the Dual-Pivot Quicksort the average number 
+  # of comparisons is 2*n*ln(n), the average number of swaps is 
+  # 0.8*n*ln(n), whereas classical Quicksort algorithm has 2*n*ln(n) 
+  # and 1*n*ln(n) respectively. This has been fully examined mathematically
+  # and experimentally.
+  #
+  # Requirements: Container should implement #pop and include the Enumerable module.
+  # Time Complexity: О(n log n) average, О(n log n) worst-case
+  # Space Complexity: О(n) auxiliary
+  #
+  # Stable: No
+  # 
+  #   Algorithms::Sort.dualpivotquicksort [5, 4, 3, 1, 2] => [1, 2, 3, 4, 5]
+
+  def self.dualpivotquicksort(container)
+    return container if container.size <= 1
+    dualpivot(container, 0, container.size-1, 3)
+  end
+ 
+  def self.dualpivot(container, left=0, right=container.size-1, div=3)
+    length = right - left
+    if length < 27 # insertion sort for tiny array
+      container.each_with_index do |data,i|
+        j = i - 1
+        while j >= 0
+          break if container[j] <= data
+          container[j + 1] = container[j]
+          j = j - 1
+        end
+        container[j + 1] = data
+      end
+    else # full dual-pivot quicksort
+      third = length / div
+      # medians
+      m1 = left + third
+      m2 = right - third
+      if m1 <= left 
+        m1 = left + 1
+      end
+      if m2 >= right
+        m2 = right - 1
+      end
+      if container[m1] < container[m2]
+        dualpivot_swap(container, m1, left)
+        dualpivot_swap(container, m2, right)
+      else
+        dualpivot_swap(container, m1, right)
+        dualpivot_swap(container, m2, left)
+      end
+      # pivots
+      pivot1 = container[left]
+      pivot2 = container[right]
+      # pointers
+      less = left + 1
+      great = right - 1
+      # sorting
+      k = less
+      while k <= great
+        if container[k] < pivot1
+          dualpivot_swap(container, k, less += 1)
+        elsif container[k] > pivot2
+          while k < great && container[great] > pivot2
+            great -= 1
+          end
+          dualpivot_swap(container, k, great -= 1)
+          if container[k] < pivot1
+            dualpivot_swap(container, k, less += 1)
+          end
+        end
+        k += 1
+      end
+      # swaps
+      dist = great - less
+      if dist < 13
+        div += 1
+      end
+      dualpivot_swap(container, less-1, left)
+      dualpivot_swap(container, great+1, right)
+      # subarrays
+      dualpivot(container, left, less-2, div)
+      dualpivot(container, great+2, right, div)
+      # equal elements
+      if dist > length - 13 && pivot1 != pivot2
+        for k in less..great do
+          if container[k] == pivot1
+            dualpivot_swap(container, k, less)
+            less += 1
+          elsif container[k] == pivot2
+            dualpivot_swap(container, k, great)
+            great -= 1
+            if container[k] == pivot1
+              dualpivot_swap(container, k, less)
+              less += 1
+            end
+          end
+        end
+      end
+      # subarray
+      if pivot1 < pivot2
+        dualpivot(container, less, great, div)
+      end
+      container
+    end
+  end
+
+  def self.dualpivot_swap(container, i, j)
+    container[i],  container[j] = container[j],  container[i]
+  end
 end
+

data/lib/algorithms/string.rb

@@ -0,0 +1,9 @@
+=begin rdoc
+    This module implements string algorithms. Documentation is provided for each algorithm.
+    
+=end
+
+begin
+  require 'CString'
+rescue LoadError
+end

data/lib/containers/heap.rb

@@ -117,6 +117,22 @@ class Containers::Heap
     @next && @next.value
   end
   
+  # call-seq:
+  #     next_key -> key
+  #     next_key -> nil
+  #
+  # Returns the key associated with the next item in heap order, but does not remove the value.
+  #
+  # Complexity: O(1)
+  #
+  #     minheap = MinHeap.new
+  #     minheap.push(1, :a)
+  #     minheap.next_key #=> 1
+  #
+  def next_key
+    @next && @next.key
+  end
+  
   # call-seq:
   #     clear -> nil
   #

data/lib/containers/kd_tree.rb

@@ -1,28 +1,55 @@
 =begin rdoc
 
-    A kd-tree allows searching of points in multi-dimensional space, increasing
-    efficiency for nearest-neighbor searching in particular.
+    A kd-tree is a binary tree that allows one to store points (of any space dimension: 2D, 3D, etc). 
+    The structure of the resulting tree makes it so that large portions of the tree are pruned
+    during queries.
+    
+    One very good use of the tree is to allow nearest neighbor searching. Let's say you have a number
+    of points in 2D space, and you want to find the nearest 2 points from a specific point:
+    
+    First, put the points into the tree:
+    
+      kdtree = Containers::KDTree.new( {0 => [4, 3], 1 => [3, 4], 2 => [-1, 2], 3 => [6, 4],
+                                       4 => [3, -5], 5 => [-2, -5] })
+    
+    Then, query on the tree:
+    
+      puts kd.find_nearest([0, 0], 2) => [[5, 2], [9, 1]]
+      
+    The result is an array of [distance, id] pairs. There seems to be a bug in this version.
+      
+    Note that the point queried on does not have to exist in the tree. However, if it does exist,
+    it will be returned.
 
 =end
 
 class Containers::KDTree
   Node = Struct.new(:id, :coords, :left, :right)
   
+  # Points is a hash of id => [coord, coord] pairs.
   def initialize(points)
-    @root = build_tree(points)
+    raise "must pass in a hash" unless points.kind_of?(Hash)
+    @dimensions = points[ points.keys.first ].size
+    @root = build_tree(points.to_a)
+    @nearest = []
+  end
+  
+  # Find k closest points to given coordinates 
+  def find_nearest(target, k_nearest)
     @nearest = []
+    nearest(@root, target, k_nearest, 0)
   end
   
-  # Build a kd-tree
+  # points is an array
   def build_tree(points, depth=0)
     return if points.empty?
-  
-    axis = depth % 2
-  
-    points.sort! { |a, b| a[1][axis] <=> b[1][axis] }
+    
+    axis = depth % @dimensions
+    
+    points.sort! { |a, b| a.last[axis] <=> b.last[axis] }
     median = points.size / 2
-  
-    node = Node.new(points[median][0], points[median][1], nil, nil)
+    
+    node = Node.new(points[median].first, points[median].last, nil, nil)
     node.left = build_tree(points[0...median], depth+1)
     node.right = build_tree(points[median+1..-1], depth+1)
     node
@@ -48,15 +75,11 @@ class Containers::KDTree
     end
     nearest
   end
+  private :check_nearest
   
-  # Find k closest points to given coordinates 
-  def find_nearest(target, k_nearest)
-    @nearest = []
-    nearest(@root, target, k_nearest, 0)
-  end
-    
+  # Recursively find nearest coordinates, going down the appropriate branch as needed
   def nearest(node, target, k_nearest, depth)
-    axis = depth % 2
+    axis = depth % @dimensions
   
     if node.left.nil? && node.right.nil? # Leaf node
       @nearest = check_nearest(@nearest, node, target, k_nearest)

data/lib/containers/trie.rb

@@ -13,7 +13,7 @@ class Containers::Trie
   #
   #   t = Containers::Trie.new
   #   t["hello"] = "world"
-  #   t["hello] #=> "world"
+  #   t["hello"] #=> "world"
   def initialize
     @root = nil
   end

data/spec/bst_gc_mark_spec.rb

@@ -0,0 +1,25 @@
+# $: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+# require 'algorithms'
+# 
+# if defined? Containers::CBst
+#   describe "CBst" 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
+#       @bst = Containers::CBst.new
+#       100.times { |x| @bst.push(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/bst_spec.rb

@@ -0,0 +1,25 @@
+# $: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+# require "algorithms"
+# 
+# begin
+#   Containers::CBst
+#   describe "binary search tree" do
+#     it "should let user push new elements with key" do
+#       @bst = Containers::CBst.new
+#       100.times { |x| @bst.push(x, "hello : #{x}") }
+#       @bst.size.should eql(100)
+#     end
+# 
+#     it "should allow users to delete elements" do
+#       @bst = Containers::CBst.new
+#       @bst.push(10, "hello world")
+#       @bst.push(11, "hello world")
+#       @bst.delete(11)
+#       @bst.size.should eql(1)
+#       @bst.delete(10)
+#       @bst.size.should eql(0)
+#     end
+#     
+#   end
+# rescue Exception
+# end

data/spec/deque_gc_mark_spec.rb

@@ -12,7 +12,7 @@ if defined? Containers::CDeque
       # Check if any instances were swept
       count = 0
       ObjectSpace.each_object(anon_class) { |x| count += 1 }
-      count.should eql(100)
+      expect(count).to eql(100)
     end
   end
 end

data/spec/deque_spec.rb

@@ -1,77 +1,77 @@
 $: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
 require 'algorithms'
 
-describe "(empty deque)", :shared => true do
+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
 
-describe "(non-empty deque)", :shared => true do
+shared_examples "(non-empty deque)" 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)
+    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