algorithms 0.0.1 → 0.1.0

data/benchmark.rb

@@ -1,4 +1,7 @@
-require 'lib/algorithms'
+# :nodoc: all
+$: << File.join(File.expand_path(File.dirname(__FILE__)), 'lib')
+require 'algorithms'
+
 require 'benchmark'
 include Benchmark
 
@@ -6,44 +9,43 @@ include Benchmark
 @random_array = []
 @num_items = 10000
 @num_items.times { |x| @random_array << rand(@num_items) }
-# @heap = DS::MaxHeap.new(@random_array)
-
+# @heap = Containers::MaxHeap.new(@random_array)
+# 
 # benchmark do |bench|
 #   bench.report("Array#max:\t ") do
 #     @num_items.times { @random_array.delete_at(@random_array.index(@random_array.max)) }
 #   end
 #   bench.report("MaxHeap:\t ") do
-#     @num_items.times { @heap.get_max! }
+#     @num_items.times { @heap.max! }
 #   end
 # end
 
+# Benchmark Deque
+deque = Containers::RubyDeque.new
+array = []
+benchmark do |bench|
+  bench.report("Array:\t ") { 1000000.times  { |x| array << x } }
+  bench.report("Deque:\t ") { 1000000.times  { |x| deque.push_back(x) } }
+end
+
 # Benchmark Search trees
-@tree = Containers::TreeMap.new
-@ctree = Containers::TreeMap.new
+@rb_tree = Containers::RubyRBTreeMap.new
+@splay_tree = Containers::SplayTreeMap.new
 @hash = Hash.new
 
 benchmark do |bench|
-  bench.report("Tree: \t") do
-    @random_array.each { |x| @tree[x] = x }
-  end
-  
-  bench.report("CTree: \t") do
-    @random_array.each { |x| @ctree[x] = x }
-  end
-  
-  bench.report("Hash: \t") do
-    @hash.each { |x| @hash[x] = x }
-  end
-
-  bench.report("Hash: \t") do
-    @num_items.times { |n| @hash.has_key?(n) }
-  end
+  puts "\nInsertion"
+  bench.report("RBTree: \t")    { @random_array.each  { |x| @rb_tree[x] = x } }
+  bench.report("SplayTree: \t") { @random_array.each  { |x| @splay_tree[x] = x } }
+  bench.report("Hash: \t\t")    { @hash.each          { |x| @hash[x] = x } }
   
-  bench.report("Tree: \t") do
-    @num_items.times { |n| @tree.contains?(n) }
-  end
+  puts "\nTest has_key?" 
+  bench.report("RBTree: \t")    { @num_items.times { |n| @rb_tree.has_key?(n) } }
+  bench.report("SplayTree: \t") { @num_items.times { |n| @splay_tree.has_key?(n) } }
+  bench.report("Hash: \t\t")    { @num_items.times { |n| @hash.has_key?(n) } }
   
-  bench.report("CTree: \t") do
-    @num_items.times { |n| @ctree.contains?(n) }
-  end
+  puts "\nSorted order" 
+  bench.report("RBTree: \t")    { @rb_tree.each { |k, v| k } }
+  bench.report("SplayTree: \t") { @splay_tree.each { |k, v| k } }
+  bench.report("Hash: \t\t")    { @hash.sort.each { |k, v| k } }
 end

data/benchmarks/rbench.rb

@@ -0,0 +1,16 @@
+require 'pathname'
+require 'benchmark'
+
+dir = Pathname(__FILE__).dirname.expand_path + 'rbench/'
+
+require dir + 'runner'
+require dir + 'column'
+require dir + 'group'
+require dir + 'report'
+require dir + 'summary'
+
+module RBench
+  def self.run(times=1, &block)
+    Runner.new(times).run(&block)
+  end
+end

data/benchmarks/rbench/column.rb

@@ -0,0 +1,26 @@
+module RBench
+  class Column
+    attr_accessor :name, :title, :width, :compare, :default
+    
+    def initialize(runner, name, options = {})
+      @runner  = runner
+      @name    = name
+      @title   = options[:title] || (@name == :times ? "" : @name.to_s.upcase)
+      @width   = options[:width] || [@title.length,7].max
+      @compare = options[:compare]
+      @default = @compare ? @compare : options[:default]
+    end
+    
+    def to_s(val=title)
+      str = case val
+        when Array      then "%#{width-1}.2f" % (val[0] / val[1]) + "x"
+        when Float      then "%#{width}.3f" % val
+        when Integer    then "%#{width}.0f" % val
+        when TrueClass  then " "*(width/2.0).floor + "X" + " "*(width/2.0).floor
+        when String     then "%#{width}s" % (val)[0,width]
+        when Object     then " " * width
+      end
+      return " #{(str.to_s+" "*width)[0,width]} |"
+    end
+  end
+end

data/benchmarks/rbench/group.rb

@@ -0,0 +1,43 @@
+module RBench
+  class Group
+    self.instance_methods.each do |m|
+      send(:undef_method, m) unless m =~ /^(__|is_a?|kind_of?|respond_to?|hash|eql?|inspect|instance_eval)/
+    end
+    
+    attr_reader :name, :items, :block, :times
+    
+    def initialize(runner, name, times=nil, &block)
+      @runner = runner
+      @name    = name
+      @items = []
+      @block = block
+      @times = times || @runner.times
+    end
+    
+    def prepare
+      # This just loops through and spawns the reports, and the summary (if exists)
+      self.instance_eval(&@block) if @block
+      # Now we want to make sure that the summary is 
+      @items << @items.shift if @items.first.is_a?(Summary)
+    end
+    
+    def run
+      # Put a separator with the group-name at the top. puts?
+      puts @runner.separator(@name)
+      # Now loop through the items in this group, and run them
+      @items.each{|item| item.run}
+    end
+
+    def report(name,times=@times,&block)
+      @items << Report.new(@runner,self,name,times,&block)
+    end
+    
+    def summary(name)
+      @items.unshift(Summary.new(@runner,self,name)) unless @items.detect{|i| i.is_a?(Summary)}
+    end
+    
+    def to_s
+      @runner.separator(@name) << @items.map { |item| item.to_s }.join
+    end
+  end
+end

data/benchmarks/rbench/report.rb

@@ -0,0 +1,53 @@
+module RBench
+  class Report
+    self.instance_methods.each do |m|
+      send(:undef_method, m) unless m =~ /^(__|is_a?|kind_of?|respond_to?|hash|inspect|instance_eval|eql?)/
+    end
+    
+    attr_reader :name, :cells
+    
+    def initialize(runner, group, name, times=nil,&block)
+      @runner = runner
+      @group  = group
+      @name   = name
+      @times  = (times || runner.times).ceil
+      @cells  = {}
+      @block  = block 
+      
+      # Setting the default for all cells
+      runner.columns.each {|c| @cells[c.name] = c.name == :times ? "x#{@times}" : c.default }
+      
+      new_self = (class << self; self end)
+      @runner.columns.each do |column|
+        new_self.class_eval <<-CLASS
+          def #{column.name}(val=nil,&block)
+            @cells[#{column.name.inspect}] = block ? Benchmark.measure { @times.times(&block) }.real : val
+          end
+        CLASS
+      end
+    end
+    
+    def run
+      # runs the actual benchmarks. If there is only one column, just evaluate the block itself.
+      if @runner.columns.length == 1
+        @cells[@runner.columns.first.name] = Benchmark.measure { @times.times(&@block) }.real
+      else
+        self.instance_eval(&@block)
+      end
+      # puts its row now that it is complete
+      puts to_s
+    end
+    
+    def to_s
+      out = "%-#{@runner.desc_width}s" % name
+      @runner.columns.each do |column|
+        value = @cells[column.name]
+        value = @cells.values_at(*value) if value.is_a?(Array)
+        value = nil if value.is_a?(Array) && value.nitems != 2
+        
+        out << column.to_s(value)
+      end
+      out << @runner.newline
+    end
+  end
+end

data/benchmarks/rbench/runner.rb

@@ -0,0 +1,109 @@
+module RBench
+  class Runner
+    attr_accessor :columns, :items, :times, :width
+    
+    def initialize(times)
+      @width = 0
+      @times = times
+      @columns = []
+      @items = []
+    end
+    
+    def run(&block)
+      
+      # initiate all the columns, groups, reports, and summaries on top level.
+      self.instance_eval(&block)
+      
+      # the groups has not run just yet, but when they do, we really only want
+      # to make them initiate their reports, not run them (just yet)
+      # when we only have two levels, _every_ report should now be initialized.
+      @items.each{|item| item.prepare if item.is_a?(Group)}
+      
+      # We are putting the summary to the back if its there.
+      @items << @items.shift if @items.first.is_a?(Summary)
+      
+      # if on columns were set, create a default column
+      column(:results, :title => "Results") if @columns.empty?
+      
+      # since we are about to start rendering, we put out the column-header
+      puts header
+      
+      # now we are ready to loop through our items and run!
+      items.each { |item| item.run if item.respond_to?(:run) }
+      
+      # returning self so people can output it in different formats.
+      self
+    end
+    
+    def format(options={})
+      @width = options.delete(:width) || @width
+    end
+    
+    def column(name,options={})
+      @columns << Column.new(self,name,options)
+    end
+    
+    def group(name,times=nil,&block)
+      @items << Group.new(self,name,times,&block)
+    end
+    
+    def report(name,times=nil,&block)
+      # create an anonymous group, or add it to the last open group.
+      group(nil) unless @items.last.is_a?(Group) && !@items.last.block
+      # now create the report on the last group
+      @items.last.report(name,times,&block)
+    end
+    
+    def summary(name)
+      # adding the summary to the front, so it is easier to put it last later.
+      @items.unshift(Summary.new(self,nil,name)) unless @items.detect{|i| i.is_a?(Summary)}
+    end
+    
+    ##
+    # convenience-methods
+    ##
+    
+    def groups
+      @items.select{|item| item.is_a?(Group) }
+    end
+
+    def reports
+      # we now want _all_ reports, also those that are part of subgroups
+      groups.map{|g| g.items.select{|item| item.is_a?(Report) } }.flatten
+    end
+    
+    ##
+    # for rendering text. pull out in separate module when to_xml and to_html is in place
+    ##
+    
+    def newline
+      "\n"
+    end
+    
+    def header
+      " " * desc_width + @columns.map {|c| c.to_s }.join + newline
+    end
+    
+    def desc_width
+      @desc_width ||= [items.map{|i| (i.items.map{|r| r.name} << i.name) }.flatten.map{|i| i.to_s.length}.max+8,@width-columns_width].max
+    end
+    
+    def columns_width
+      @columns.inject(0){ |tot,c| tot += (c.to_s.length) }
+    end
+    
+    def width(value=nil)
+      header.length-1
+    end
+
+    def separator(title=nil,chr="-",length=width)
+      title ? chr*2 + title + chr * (width - title.length - 2) : chr * length
+    end
+    
+    def to_s
+      out = " " * desc_width + @columns.map {|c| c.to_s }.join + newline
+      out << @items.map {|item| item.to_s}.join
+    end
+    
+  end
+end

data/benchmarks/rbench/summary.rb

@@ -0,0 +1,51 @@
+module RBench
+  class Summary
+    attr_reader :name, :runner, :cells, :items
+    attr_accessor :lines
+    
+    def initialize(runner, group, name)
+      @runner = runner
+      @group  = group
+      @name   = name
+      @cells  = {}     # A hash with keys as columns, and values being the result
+      @items  = []
+    end
+    
+    def run
+      # maybe add convenience-method to group to. group == runner really.
+      items = (@group ? @group.items & @runner.reports : @runner.reports)
+      
+      rows = items.map{|item| item.cells.values_at(*@runner.columns.map{|c|c.name}) }
+      rows = rows.pop.zip(*rows)
+
+      @runner.columns.each_with_index do |c,i|
+        if c.compare
+          value,comparisons = 0,0
+          items.each do |item|
+            v1,v2 = *item.cells.values_at(*c.compare)
+            if v1.kind_of?(Numeric) && v2.kind_of?(Numeric) && v1 != 0 && v2 != 0
+              value += v1 / v2
+              comparisons += 1
+            end
+          end
+          @cells[c.name] = [value,comparisons] if comparisons > 0
+        elsif c.name != :times
+          @cells[c.name] = rows[i].compact.select{|r| r.kind_of?(Numeric)}.inject(0){|tot,v| tot += v.to_f }
+        end
+      end
+      
+      puts to_s
+    end
+    
+    def to_s
+      out = ""
+      out << @runner.separator(nil,"=") + @runner.newline unless @group
+      out << "%-#{@runner.desc_width}s" % name
+      @runner.columns.each do |column|
+        value = @cells[column.name]
+        out << column.to_s( value )
+      end
+      out << @runner.newline
+    end
+  end
+end

data/benchmarks/sorts.rb

@@ -0,0 +1,33 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '../lib')
+require 'algorithms'
+include Algorithms
+
+require 'rbench'
+
+RBench.run(5) do
+  
+  sorts = %w(built_in comb_sort heapsort insertion_sort shell_sort quicksort mergesort)
+  sorts.each { |sort| self.send(:column, sort.intern) }
+  
+  n = 1000
+  
+  proc = lambda { |scope, ary|
+    scope.built_in { ary.dup.sort }
+    scope.comb_sort { Sort.comb_sort(ary.dup) }
+    scope.heapsort { Sort.heapsort(ary.dup) }
+    scope.insertion_sort { Sort.insertion_sort(ary.dup) }
+    scope.shell_sort { Sort.shell_sort(ary.dup) }
+    scope.quicksort { Sort.quicksort(ary.dup) }
+    scope.mergesort { Sort.mergesort(ary.dup) }
+  }
+
+  report "Already sorted" do
+    sorted_array = Array.new(n) { rand(n) }.sort
+    proc.call(self, sorted_array)
+  end
+  
+  report "Random" do
+    random_array = Array.new(n) { rand(n) }
+    proc.call(self, random_array)
+  end
+end

data/ext/containers/bst/bst.c

@@ -0,0 +1,205 @@
+#include "ruby.h"
+#include <ctype.h>
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+/* for compatibility with Ruby 1.8.5, which doesn't declare RSTRING_LEN */
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+typedef struct struct_bst_node {
+  VALUE key;
+  VALUE data;
+  struct struct_bst_node *left;
+  struct struct_bst_node *right;
+  struct struct_bst_node *parent;
+} bst_node;
+
+
+typedef struct struct_bst_head {
+  bst_node *head; 
+  unsigned int size; 
+} bst_head;
+
+static VALUE bst_initialize(VALUE self) {
+  return self;
+}
+
+static void in_order_display (bst_node *root) {
+  if (root) {
+    in_order_display(root->left);
+    rb_yield(rb_assoc_new(root->key,root->data));
+    in_order_display(root->right);
+  }
+}
+
+static int id_compare_operator;
+
+static int rb_key_compare(VALUE a, VALUE b) {
+  return FIX2INT(rb_funcall((VALUE) a, id_compare_operator, 1, (VALUE) b));
+}
+
+static void insert_element(bst_node **root,bst_node *newElement) {
+  bst_node *y = NULL;
+  bst_node *x = *root;
+  while (x != NULL) {
+    y = x;
+    //if (newElement->key < x->key) x = x->left;
+    if (rb_key_compare(newElement->key,x->key) < 0) x = x->left;
+    else x = x->right;
+  }
+  newElement->parent = y;
+  if (y == NULL) *root = newElement;
+  //else if (newElement->key < y->key) y->left = newElement;
+  else if (rb_key_compare(newElement->key,y->key) < 0) y->left = newElement;
+  else y->right = newElement;
+}
+
+
+static bst_node *create_element(VALUE key_data,VALUE data) {
+  bst_node *arbit = malloc(sizeof(bst_node));
+  arbit->data = data;
+  arbit->key = key_data;
+  arbit->left = NULL;
+  arbit->right = NULL;
+  arbit->parent = NULL;
+  return arbit;  
+}
+
+
+static bst_node *tree_minimum (bst_node *root) {
+  bst_node *x = root;
+  while (x->left) x = x->left;
+  return x;
+}
+
+
+static bst_node *tree_maximum (bst_node *root) {
+  bst_node *x = root;
+  while (x->right) x = x->right;
+  return x;
+}
+
+static bst_node *node_successor (bst_node *root,bst_node *x) {
+  if (x->right) return tree_minimum(x->right);
+  bst_node *y = x->parent;
+  while (y && x == y->right) {
+    x = y;
+    y = x->parent;
+  }
+  return y;
+}
+
+
+bst_node *delete_node (bst_node **root,bst_node *tobeDeleted) {
+  bst_node *y,*x;
+  
+  if ((tobeDeleted->left == NULL) || (tobeDeleted->right == NULL)) y = tobeDeleted;
+  else y = node_successor(*root,tobeDeleted);
+  
+  if (y->left) x = y->left;
+  else x = y->right;
+  
+  if (x) x->parent = y->parent;
+  
+  if (y->parent == NULL) {
+    *root = x;
+    return y;
+  } else if (y == y->parent->left) {
+    y->parent->left = x;
+  } else {
+    y->parent->right = x;
+  }
+  
+  if (tobeDeleted != y) tobeDeleted->key = y->key;
+  return y;
+}
+
+bst_node *search_node (bst_node *root,VALUE key) {
+  bst_node *x = root;
+  while (x) {
+    //if (x->key == key) return x;
+    if (rb_key_compare(x->key,key) == 0) return x;
+    //else if (key < x->key) x = x->left;
+    else if (rb_key_compare(key,x->key) < 0) x = x->left;
+    else x = x->right;
+  }
+  return NULL;
+}
+
+void delete_nodes_recur(bst_node *root) {
+  if(root) {
+    delete_nodes_recur(root->left);
+    if(root) free(root);
+    delete_nodes_recur(root->right);
+  }
+}
+
+static void bst_free_node(void *p) {
+  bst_head *headNode = (bst_head *)p;
+  delete_nodes_recur(headNode->head);
+}
+
+static VALUE bst_alloc(VALUE klass) {
+  bst_head *headNode = ALLOC(bst_head);
+  headNode->head = NULL;
+  headNode->size = 0;
+  VALUE obj;
+  obj = Data_Wrap_Struct(klass,NULL,bst_free_node,headNode);
+  return obj;
+}
+
+static VALUE rb_bst_insert_value(VALUE self,VALUE key,VALUE data) {
+  bst_head *headNode;
+  Data_Get_Struct(self,bst_head,headNode);
+  insert_element(&(headNode->head),create_element(key,data));
+  headNode->size++;
+  return self;
+}
+
+/* data structure builds up a stack for traversal, delete can be harmful */
+static VALUE rb_bst_each(VALUE self)
+{
+  bst_head *headNode;
+  Data_Get_Struct(self,bst_head,headNode);
+  in_order_display(headNode->head);
+  return Qnil;
+}
+
+static VALUE rb_bst_delete(VALUE self,VALUE keyVal) {
+  //int key = FIX2INT(keyVal);
+  bst_head *headNode;
+  Data_Get_Struct(self,bst_head,headNode);
+  bst_node *tobeDeleted = search_node(headNode->head,keyVal);
+  if(tobeDeleted) { 
+    headNode->size = headNode->size - 1;
+    bst_node *deletedNode = delete_node(&(headNode->head),tobeDeleted);
+    return deletedNode->data;
+  } else { 
+    rb_raise(rb_eArgError, "Key was not found");
+    return Qnil;
+  }
+}
+
+static VALUE rb_bst_size(VALUE self) { 
+  bst_head *headNode;
+  Data_Get_Struct(self,bst_head,headNode);
+  return INT2FIX(headNode->size);
+}
+
+static VALUE mContainers;
+
+void Init_CBst() {
+  id_compare_operator = rb_intern("<=>");
+  mContainers = rb_define_module("Containers");
+  VALUE cbst_class = rb_define_class_under(mContainers,"CBst",rb_cObject);
+  rb_define_alloc_func(cbst_class,bst_alloc);
+  rb_define_method(cbst_class,"initialize",bst_initialize,0);
+  rb_define_method(cbst_class,"insert",rb_bst_insert_value,2);
+  rb_define_method(cbst_class,"each", rb_bst_each,0);
+  rb_define_method(cbst_class,"delete",rb_bst_delete,1);
+  rb_define_method(cbst_class,"size",rb_bst_size,0);
+}