algorithms 0.1.0 → 0.2.0

data/benchmarks/rbench.rb

@@ -1,16 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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/ext/containers/bst/bst.c

@@ -1,205 +0,0 @@
-#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);
-}