algorithms 0.1.0 → 0.2.0

data/History.txt

@@ -1,3 +1,11 @@
+=== March 28, 2009
+
+	* Implemented SplayTree in C
+	* Made recursively_free_nodes methods static to fix a SEGFAULT
+	* Improved CBst
+	* Moved to Markdown for README
+	* 0.2.0 release
+
 === January 19, 2009
 
   * kd-tree for points in multi-dimensional space

data/Manifest

@@ -1,18 +1,13 @@
 algorithms.gemspec
-benchmark.rb
-benchmarks/rbench/column.rb
-benchmarks/rbench/group.rb
-benchmarks/rbench/report.rb
-benchmarks/rbench/runner.rb
-benchmarks/rbench/summary.rb
-benchmarks/rbench.rb
+benchmarks/deque.rb
 benchmarks/sorts.rb
-ext/containers/bst/bst.c
-ext/containers/bst/extconf.rb
+benchmarks/treemaps.rb
 ext/containers/deque/deque.c
 ext/containers/deque/extconf.rb
-ext/containers/tree_map/extconf.rb
-ext/containers/tree_map/rbtree.c
+ext/containers/rbtree_map/extconf.rb
+ext/containers/rbtree_map/rbtree.c
+ext/containers/splaytree_map/extconf.rb
+ext/containers/splaytree_map/splaytree.c
 History.txt
 lib/algorithms/search.rb
 lib/algorithms/sort.rb
@@ -27,16 +22,16 @@ lib/containers/splay_tree_map.rb
 lib/containers/stack.rb
 lib/containers/suffix_array.rb
 lib/containers/trie.rb
-lib/graphs/graph.rb
 Manifest
 Rakefile
-README
-spec/bst_spec.rb
+README.markdown
+spec/deque_gc_mark_spec.rb
 spec/deque_spec.rb
 spec/heap_spec.rb
 spec/kd_tree_spec.rb
 spec/priority_queue_spec.rb
 spec/queue_spec.rb
+spec/rb_tree_map_gc_mark_spec.rb
 spec/rb_tree_map_spec.rb
 spec/search_spec.rb
 spec/sort_spec.rb

data/README.markdown

@@ -0,0 +1,92 @@
+# algorithms
+
+* Official homes are here on github, and at [rubyforge](http://rubyforge.org/projects/algorithms/)
+* Documentation: [http://algorithms.rubyforge.org/](http://algorithms.rubyforge.org/)
+
+## DESCRIPTION:
+
+Started as a [Google Summer of Code 2008](http://code.google.com/soc/2008/ruby/about.html) project
+
+Written by [Kanwei Li](http://kanwei.com/), mentored by Austin Ziegler
+
+Original Proposal: Using the right data structure or algorithm for the situation is an important
+aspect of programming. In computer science literature, many data structures
+and algorithms have been researched and extensively documented. However, there
+is still no standard library in Ruby implementing useful structures and
+algorithms like Red/Black Trees, tries, different sorting algorithms, etc.
+This project will create such a library with documentation on when to use a
+particular structure/algorithm. It will also come with a benchmark suite to
+compare performance in different situations.
+
+## FEATURES:
+
+Done so far:
+
+		* Heaps              Containers::Heap, Containers::MaxHeap, Containers::MinHeap
+		* Priority Queue     Containers::PriorityQueue
+		* Deque              Containers::Deque, Containers::CDeque (C extension), Containers::RubyDeque
+		* Stack              Containers::Stack (uses Deque)
+		* Queue              Containers::Queue (uses Deque)
+		* Red-Black Trees    Containers::RBTreeMap, Containers::CRBTreeMap (C extension), Containers::RubyRBTreeMap
+		* Splay Trees        Containers::SplayTreeMap, Containers::CSplayTreeMap (C extension), Containers::RubySplayTreeMap
+		* Tries              Containers::Trie
+		* Suffix Array       Containers::SuffixArray
+
+		* Search algorithms
+		  - Binary Search            Algorithms::Search.binary_search
+		  - Knuth-Morris-Pratt       Algorithms::Search.kmp_search
+		* Sort algorithms           
+		  - Bubble sort              Algorithms::Sort.bubble_sort
+		  - Comb sort                Algorithms::Sort.comb_sort
+		  - Selection sort           Algorithms::Sort.selection_sort
+		  - Heapsort                 Algorithms::Sort.heapsort
+		  - Insertion sort           Algorithms::Sort.insertion_sort
+		  - Shell sort               Algorithms::Sort.shell_sort
+		  - Quicksort                Algorithms::Sort.quicksort
+		  - Mergesort                Algorithms::Sort.mergesort
+
+## SYNOPSIS:
+
+		require 'rubygems'
+		require 'algorithms'
+		
+		max_heap = Containers::MaxHeap.new
+		
+		# To not have to type "Containers::" before each class, use:
+		include Containers
+		max_heap = MaxHeap.new
+
+
+## REQUIREMENTS:
+
+* Ruby 1.8 compatible Ruby, or Ruby 1.9
+* C compiler for C extensions (optional, but very much recommended for vast performance benefits)
+
+## INSTALL:
+
+* sudo gem install algorithms
+
+## LICENSE:
+
+(The MIT License)
+
+Algorithms and Containers project is Copyright (c) 2009 Kanwei Li
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -6,7 +6,7 @@ Echoe.new('algorithms') do |p|
   p.email                = 'kanwei@gmail.com'
   p.summary              = 'A library of algorithms and containers.'
   p.url                  = 'http://rubyforge.org/projects/algorithms/'
-  p.version              = "0.1.0"
+  p.version              = "0.2.0"
   p.runtime_dependencies = []
 end
 
@@ -18,8 +18,9 @@ end
 
 task :push do
   sh "git push"    # Rubyforge
-  sh "git push gt" # Gitorious
+  sh "git push --tags"    # Rubyforge
   sh "git push gh" # Github
+  sh "git push gh --tags" # Github
 end
 
 task :hanna do

data/algorithms.gemspec

@@ -2,19 +2,19 @@
 
 Gem::Specification.new do |s|
   s.name = %q{algorithms}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kanwei Li"]
-  s.date = %q{2009-02-21}
+  s.date = %q{2009-03-29}
   s.description = %q{A library of algorithms and containers.}
   s.email = %q{kanwei@gmail.com}
-  s.extensions = ["ext/containers/bst/extconf.rb", "ext/containers/deque/extconf.rb", "ext/containers/tree_map/extconf.rb"]
-  s.extra_rdoc_files = ["ext/containers/bst/bst.c", "ext/containers/bst/extconf.rb", "ext/containers/deque/deque.c", "ext/containers/deque/extconf.rb", "ext/containers/tree_map/extconf.rb", "ext/containers/tree_map/rbtree.c", "lib/algorithms/search.rb", "lib/algorithms/sort.rb", "lib/algorithms.rb", "lib/containers/deque.rb", "lib/containers/heap.rb", "lib/containers/kd_tree.rb", "lib/containers/priority_queue.rb", "lib/containers/queue.rb", "lib/containers/rb_tree_map.rb", "lib/containers/splay_tree_map.rb", "lib/containers/stack.rb", "lib/containers/suffix_array.rb", "lib/containers/trie.rb", "lib/graphs/graph.rb", "README"]
-  s.files = ["algorithms.gemspec", "benchmark.rb", "benchmarks/rbench/column.rb", "benchmarks/rbench/group.rb", "benchmarks/rbench/report.rb", "benchmarks/rbench/runner.rb", "benchmarks/rbench/summary.rb", "benchmarks/rbench.rb", "benchmarks/sorts.rb", "ext/containers/bst/bst.c", "ext/containers/bst/extconf.rb", "ext/containers/deque/deque.c", "ext/containers/deque/extconf.rb", "ext/containers/tree_map/extconf.rb", "ext/containers/tree_map/rbtree.c", "History.txt", "lib/algorithms/search.rb", "lib/algorithms/sort.rb", "lib/algorithms.rb", "lib/containers/deque.rb", "lib/containers/heap.rb", "lib/containers/kd_tree.rb", "lib/containers/priority_queue.rb", "lib/containers/queue.rb", "lib/containers/rb_tree_map.rb", "lib/containers/splay_tree_map.rb", "lib/containers/stack.rb", "lib/containers/suffix_array.rb", "lib/containers/trie.rb", "lib/graphs/graph.rb", "Manifest", "Rakefile", "README", "spec/bst_spec.rb", "spec/deque_spec.rb", "spec/heap_spec.rb", "spec/kd_tree_spec.rb", "spec/priority_queue_spec.rb", "spec/queue_spec.rb", "spec/rb_tree_map_spec.rb", "spec/search_spec.rb", "spec/sort_spec.rb", "spec/splay_tree_map_spec.rb", "spec/stack_spec.rb", "spec/suffix_array_spec.rb", "spec/trie_spec.rb"]
+  s.extensions = ["ext/containers/deque/extconf.rb", "ext/containers/rbtree_map/extconf.rb", "ext/containers/splaytree_map/extconf.rb"]
+  s.extra_rdoc_files = ["ext/containers/deque/deque.c", "ext/containers/deque/extconf.rb", "ext/containers/rbtree_map/extconf.rb", "ext/containers/rbtree_map/rbtree.c", "ext/containers/splaytree_map/extconf.rb", "ext/containers/splaytree_map/splaytree.c", "lib/algorithms/search.rb", "lib/algorithms/sort.rb", "lib/algorithms.rb", "lib/containers/deque.rb", "lib/containers/heap.rb", "lib/containers/kd_tree.rb", "lib/containers/priority_queue.rb", "lib/containers/queue.rb", "lib/containers/rb_tree_map.rb", "lib/containers/splay_tree_map.rb", "lib/containers/stack.rb", "lib/containers/suffix_array.rb", "lib/containers/trie.rb", "README.markdown"]
+  s.files = ["algorithms.gemspec", "benchmarks/deque.rb", "benchmarks/sorts.rb", "benchmarks/treemaps.rb", "ext/containers/deque/deque.c", "ext/containers/deque/extconf.rb", "ext/containers/rbtree_map/extconf.rb", "ext/containers/rbtree_map/rbtree.c", "ext/containers/splaytree_map/extconf.rb", "ext/containers/splaytree_map/splaytree.c", "History.txt", "lib/algorithms/search.rb", "lib/algorithms/sort.rb", "lib/algorithms.rb", "lib/containers/deque.rb", "lib/containers/heap.rb", "lib/containers/kd_tree.rb", "lib/containers/priority_queue.rb", "lib/containers/queue.rb", "lib/containers/rb_tree_map.rb", "lib/containers/splay_tree_map.rb", "lib/containers/stack.rb", "lib/containers/suffix_array.rb", "lib/containers/trie.rb", "Manifest", "Rakefile", "README.markdown", "spec/deque_gc_mark_spec.rb", "spec/deque_spec.rb", "spec/heap_spec.rb", "spec/kd_tree_spec.rb", "spec/priority_queue_spec.rb", "spec/queue_spec.rb", "spec/rb_tree_map_gc_mark_spec.rb", "spec/rb_tree_map_spec.rb", "spec/search_spec.rb", "spec/sort_spec.rb", "spec/splay_tree_map_spec.rb", "spec/stack_spec.rb", "spec/suffix_array_spec.rb", "spec/trie_spec.rb"]
   s.has_rdoc = true
   s.homepage = %q{http://rubyforge.org/projects/algorithms/}
-  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Algorithms", "--main", "README"]
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Algorithms", "--main", "README.markdown"]
   s.require_paths = ["lib", "ext"]
   s.rubyforge_project = %q{algorithms}
   s.rubygems_version = %q{1.3.1}

data/benchmarks/deque.rb

@@ -0,0 +1,17 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '../lib')
+require 'algorithms'
+include Algorithms
+
+require 'rubygems'
+require 'rbench'
+
+RBench.run(2) do
+  %w(array deque).each { |s| self.send(:column, s.intern) }
+  deque = Containers::Deque.new
+  array = []
+  
+  report "Insertion at end" do
+    array { 1000000.times  { |x| array << x } }
+    deque { 1000000.times  { |x| deque.push_back(x) } }
+  end
+end

data/benchmarks/sorts.rb

@@ -2,17 +2,18 @@ $: << File.join(File.expand_path(File.dirname(__FILE__)), '../lib')
 require 'algorithms'
 include Algorithms
 
+require 'rubygems'
 require 'rbench'
 
 RBench.run(5) do
   
-  sorts = %w(built_in comb_sort heapsort insertion_sort shell_sort quicksort mergesort)
+  sorts = %w(ruby 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.ruby { 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) }

data/benchmarks/treemaps.rb

@@ -0,0 +1,36 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '../lib')
+require 'algorithms'
+include Algorithms
+
+require 'rubygems'
+require 'rbench'
+
+RBench.run(10) do
+  trees = %w(hash rbtree splaytree)
+  trees.each { |tree| self.send(:column, tree.intern) }
+  
+  rbtree = Containers::RBTreeMap.new
+  splaytree = Containers::SplayTreeMap.new
+  hash = Hash.new
+  
+  random_array = Array.new(10000) { |i| rand(i) }
+  num = 1000
+  
+  report "Insertion" do
+    rbtree { random_array.each_with_index  { |x,index| rbtree[index] = x } }
+    splaytree { random_array.each_with_index  { |x,index| splaytree[index] = x } }
+    hash { random_array.each_with_index  { |x,index| hash[index] = x } }
+  end
+  
+  report "has_key?" do
+    rbtree { num.times { |n| rbtree.has_key?(n) } }
+    splaytree { num.times { |n| splaytree.has_key?(n) } }
+    hash { num.times { |n| hash.has_key?(n) } }
+  end
+  
+  report "Lookup in sorted order" do
+    rbtree { rbtree.each { |k, v| k } }
+    splaytree { splaytree.each { |k, v| k } }
+    hash { hash.sort.each { |k, v| k } }
+  end
+end

data/ext/containers/deque/deque.c

@@ -56,14 +56,28 @@ static deque_node* create_node(VALUE obj) {
 	return node;
 }
 
-static void deque_free(deque *deque) {
-	free_nodes(deque->front);
-	free(deque);
+static void deque_mark(void *ptr) {
+  if (ptr) {
+		deque *deque = ptr;
+		deque_node *node = deque->front;
+		while(node) {
+			rb_gc_mark(node->obj);
+			node = node->right;
+		}
+	}
+}
+
+static void deque_free(void *ptr) {
+	if (ptr) {
+		deque *deque = ptr;
+		free_nodes(deque->front);
+		free(deque);
+	}
 }
 
 static VALUE deque_alloc(VALUE klass) {
 	deque *deque = create_deque();
-	return Data_Wrap_Struct(klass, NULL, deque_free, deque);
+	return Data_Wrap_Struct(klass, deque_mark, deque_free, deque);
 }
 
 static VALUE deque_push_front(VALUE self, VALUE obj) {

data/ext/containers/{tree_map → rbtree_map}/rbtree.c

@@ -22,7 +22,7 @@ typedef struct {
 	rbtree_node *root;
 } rbtree;
 
-void recursively_free_nodes(rbtree_node *node) {
+static void recursively_free_nodes(rbtree_node *node) {
 	if(node) {
 		recursively_free_nodes(node->left);
 		recursively_free_nodes(node->right);
@@ -37,7 +37,7 @@ static rbtree* get_tree_from_self(VALUE self) {
 	return tree;
 }
 
-int isred(rbtree_node *node) {
+static int isred(rbtree_node *node) {
 	if(!node) { return FALSE; }
 	
 	if(node->color == RED) { return TRUE; }
@@ -176,17 +176,17 @@ static VALUE get(rbtree *tree, rbtree_node *node, VALUE key) {
 }
 
 static VALUE min_key(rbtree_node *node) {
-	if (!node->left)
-		return node->key;
+	while (node->left)
+		node = node->left;
 		
-	return min_key(node->left);
+	return node->key;
 }
 
 static VALUE max_key(rbtree_node *node) {
-	if (!node->right)
-		return node->key;
+	while (node->right)
+		node = node->right;
 	
-	return max_key(node->right);
+	return node->key;
 }
 
 static rbtree_node* delete_min(rbtree_node *h, VALUE *deleted_value) {
@@ -285,6 +285,17 @@ static rbtree* rbt_each(rbtree *tree, void (*each)(rbtree *tree, rbtree_node *no
 static int id_compare_operator;
 
 static int rbtree_compare_function(VALUE a, VALUE b) {
+	if (a == b) return 0;
+	if (FIXNUM_P(a) && FIXNUM_P(b)) {
+		long x = FIX2LONG(a), y = FIX2LONG(b);
+		if (x == y) return 0;
+		if (x > y) return 1;
+		return -1;
+	}
+	if (TYPE(a) == T_STRING && RBASIC(a)->klass == rb_cString &&
+			TYPE(b) == T_STRING && RBASIC(b)->klass == rb_cString) {
+		return rb_str_cmp(a, b);
+	}
 	return FIX2INT(rb_funcall((VALUE) a, id_compare_operator, 1, (VALUE) b));
 }
 
@@ -293,14 +304,33 @@ static VALUE rbtree_init(VALUE self)
 	return self;
 }
 
-static void rbtree_free(rbtree *tree) {
-	recursively_free_nodes(tree->root);
-	free(tree);
+static void recursively_mark_nodes(rbtree_node *node) {
+	if(node) {
+		rb_gc_mark(node->key);
+		rb_gc_mark(node->value);
+		recursively_mark_nodes(node->left);
+		recursively_mark_nodes(node->right);
+	}
+}
+
+static void rbtree_mark(void *ptr) {
+	if (ptr) {
+		rbtree *tree = ptr;
+		recursively_mark_nodes(tree->root);
+	}
+}
+
+static void rbtree_free(void *ptr) {
+	if (ptr) {
+		rbtree *tree = ptr;
+		recursively_free_nodes(tree->root);
+		free(tree);
+	}
 }
 
 static VALUE rbtree_alloc(VALUE klass) {
 	rbtree *tree = create_rbtree(&rbtree_compare_function);
-	return Data_Wrap_Struct(klass, NULL, rbtree_free, tree);
+	return Data_Wrap_Struct(klass, rbtree_mark, rbtree_free, tree);
 }
 
 static VALUE rbtree_push(VALUE self, VALUE key, VALUE value) {

data/ext/containers/{bst → splaytree_map}/extconf.rb

@@ -1,4 +1,4 @@
 require 'mkmf'
-extension_name = "CBst"
+extension_name = "CSplayTreeMap"
 dir_config(extension_name)
 create_makefile(extension_name)

data/ext/containers/splaytree_map/splaytree.c

@@ -0,0 +1,370 @@
+#include "ruby.h"
+
+typedef struct struct_splaytree_node {
+	VALUE key;
+	VALUE value;
+	struct struct_splaytree_node *left;
+	struct struct_splaytree_node *right;
+} splaytree_node;
+
+typedef struct {
+	int (*compare_function)(VALUE key1, VALUE key2);
+	int size;
+	splaytree_node *root;
+	splaytree_node *header;
+} splaytree;
+
+static void recursively_free_nodes(splaytree_node *node) {
+	if(node) {
+		recursively_free_nodes(node->left);
+		recursively_free_nodes(node->right);
+		free(node);
+	}
+	return;
+}
+
+static splaytree* get_tree_from_self(VALUE self) {
+	splaytree *tree;
+	Data_Get_Struct(self, splaytree, tree);
+	return tree;
+}
+
+static void splay(splaytree *tree, VALUE key) {
+	int cmp, cmp2;
+	splaytree_node *l, *r, *t, *y;
+	
+	l = tree->header;
+	r = tree->header;
+	t = tree->root;
+	
+	tree->header->left = NULL;
+	tree->header->right = NULL;
+	
+	while(1) {
+		cmp = tree->compare_function(key, t->key);
+		if (cmp == -1) {
+			if (!(t->left)) break;
+			cmp2 = tree->compare_function(key, t->left->key);
+			if (cmp2 == -1) {
+				y = t->left;
+				t->left = y->right;
+				y->right = t;
+				t = y;
+          		if (!(t->left)) break;
+			}
+			r->left = t;
+			r = t;
+			t = t->left;
+		}
+		else if (cmp == 1) {
+			if (!(t->right)) break;
+			cmp2 = tree->compare_function(key, t->right->key);
+			if (cmp2 == 1) {
+				y = t->right;
+				t->right = y->left;
+				y->left = t;
+				t = y;
+          		if (!(t->right)) break;
+			}
+			l->right = t;
+			l = t;
+			t = t->right;
+		} else {
+			break;
+		}
+	}
+	l->right = t->left;
+	r->left = t->right;
+	t->left = tree->header->right;
+    t->right = tree->header->left;
+	tree->root = t;
+}
+
+static int height(splaytree_node *h) {
+	int left_height, right_height;
+	
+	if(!h) { return 0; }
+	
+	left_height = 1 + height(h->left);
+	right_height = 1 + height(h->right);
+	
+	return left_height > right_height ? left_height : right_height;
+}
+
+static splaytree* create_splaytree(int (*compare_function)(VALUE, VALUE)) {
+	splaytree *tree = ALLOC(splaytree);
+	tree->compare_function = compare_function;
+	tree->root = NULL;
+	tree->size = 0;
+	tree->header = ALLOC(splaytree_node);
+	return tree;
+}
+
+static splaytree_node* create_node(VALUE key, VALUE value) {
+	splaytree_node *new_node = ALLOC(splaytree_node);
+	new_node->key		= key;
+	new_node->value		= value;
+	new_node->left		= NULL;
+	new_node->right		= NULL;
+	return new_node;
+}
+
+static void insert(splaytree *tree, VALUE key, VALUE value) {
+	int cmp;
+	splaytree_node *new_node;
+	
+	if (!(tree->root)) {
+		new_node = create_node(key, value);
+		tree->root = new_node;
+		tree->size += 1;
+		return;
+	}
+	
+	splay(tree, key);
+	cmp = tree->compare_function(key, tree->root->key);
+	if (cmp == 0) {
+		tree->root->value = value;
+		return;
+	} else {
+		new_node = create_node(key, value);
+		if (cmp == -1) { 
+			new_node->left = tree->root->left;
+			new_node->right = tree->root;
+			tree->root->left = NULL;
+		} else { /* cmp == 1 */
+			new_node->right = tree->root->right;
+			new_node->left = tree->root;
+			tree->root->right = NULL;
+		}
+		tree->root = new_node;
+		tree->size += 1;
+	}
+}
+
+static VALUE get(splaytree *tree, VALUE key) {
+	int cmp;
+	if (!tree->root)
+		return Qnil;
+	
+	splay(tree, key);
+	cmp = tree->compare_function(key, tree->root->key);
+	if (cmp == 0) {
+		return tree->root->value;
+	}
+	return Qnil;
+}
+
+static VALUE delete(splaytree *tree, VALUE key) {
+	int cmp;
+	splaytree_node *x, *deleted_root;
+	VALUE deleted;
+
+	splay(tree, key);
+	cmp = tree->compare_function(key, tree->root->key);
+	if (cmp == 0) {
+		deleted = tree->root->value;
+		deleted_root = tree->root;
+		if (!(tree->root->left)) {
+			tree->root = tree->root->right;
+		} else {
+			x = tree->root->right;
+			tree->root = tree->root->left;
+			splay(tree, key);
+			tree->root->right = x;
+		}
+		free(deleted_root);
+		tree->size -= 1;
+		return deleted;
+	}
+	return Qnil;
+}
+
+static splaytree* splaytree_each_node(splaytree *tree, splaytree_node *node, void (*each)(splaytree *tree_, splaytree_node *node_, void* args), void* arguments) {
+	if (!node)
+		return NULL;
+	
+		if (node->left)
+			splaytree_each_node(tree, node->left, each, arguments);
+		
+		(*each)(tree, node, arguments);
+		
+		if (node->right)
+			splaytree_each_node(tree, node->right, each, arguments);
+	return tree;
+}
+
+static splaytree* splay_each(splaytree *tree, void (*each)(splaytree *tree, splaytree_node *node, void *args), void* arguments) {
+	if (tree->root)
+		splaytree_each_node(tree, tree->root, each, arguments);
+	return tree;
+}
+
+// Methods to be called in Ruby
+
+static int id_compare_operator;
+
+static int splaytree_compare_function(VALUE a, VALUE b) {
+	if (a == b) return 0;
+	if (FIXNUM_P(a) && FIXNUM_P(b)) {
+		long x = FIX2LONG(a), y = FIX2LONG(b);
+		if (x == y) return 0;
+		if (x > y) return 1;
+		return -1;
+	}
+	if (TYPE(a) == T_STRING && RBASIC(a)->klass == rb_cString &&
+			TYPE(b) == T_STRING && RBASIC(b)->klass == rb_cString) {
+		return rb_str_cmp(a, b);
+	}
+	return FIX2INT(rb_funcall((VALUE) a, id_compare_operator, 1, (VALUE) b));
+}
+
+static VALUE splaytree_init(VALUE self)
+{
+	return self;
+}
+
+static void recursively_mark_nodes(splaytree_node *node) {
+	if(node) {
+		rb_gc_mark(node->key);
+		rb_gc_mark(node->value);
+		recursively_mark_nodes(node->left);
+		recursively_mark_nodes(node->right);
+	}
+}
+
+static void splaytree_mark(void *ptr) {
+	if (ptr) {
+		splaytree *tree = ptr;
+		recursively_mark_nodes(tree->root);
+	}
+}
+
+static void splaytree_free(void *ptr) {
+	if (ptr) {
+		splaytree *tree = ptr;
+		recursively_free_nodes(tree->root);
+		free(tree->header);
+		free(tree);
+	}
+}
+
+static VALUE splaytree_alloc(VALUE klass) {
+	splaytree *tree = create_splaytree(&splaytree_compare_function);
+	return Data_Wrap_Struct(klass, splaytree_mark, splaytree_free, tree);
+}
+
+static VALUE splaytree_push(VALUE self, VALUE key, VALUE value) {
+	splaytree *tree = get_tree_from_self(self);
+	insert(tree, key, value);
+	return value;
+}
+
+static VALUE splaytree_get(VALUE self, VALUE key) {
+	splaytree *tree = get_tree_from_self(self);
+	return get(tree, key);
+}
+
+static VALUE splaytree_size(VALUE self) {
+	splaytree *tree = get_tree_from_self(self);
+	return INT2NUM(tree->size);
+}
+
+static VALUE splaytree_is_empty(VALUE self) {
+	splaytree *tree = get_tree_from_self(self);
+	return (tree->root ? Qfalse : Qtrue);
+}
+
+static VALUE splaytree_height(VALUE self) {
+	splaytree *tree = get_tree_from_self(self);
+	return INT2NUM(height(tree->root));
+}
+
+static VALUE splaytree_has_key(VALUE self, VALUE key) {
+	splaytree *tree = get_tree_from_self(self);
+	if(!tree->root) { return Qfalse; }
+	if(get(tree, key) == Qnil)
+		return Qfalse;
+	
+	return Qtrue;
+}
+
+static VALUE splaytree_min_key(VALUE self) {
+	splaytree *tree = get_tree_from_self(self);
+	splaytree_node *node;
+	
+	if(!tree->root)
+		return Qnil;
+	
+	node = tree->root;
+	while (node->left)
+		node = node->left;
+	
+	return node->key;
+}
+
+static VALUE splaytree_max_key(VALUE self) {
+	splaytree *tree = get_tree_from_self(self);
+	splaytree_node *node;
+	
+	if(!tree->root)
+		return Qnil;
+	
+	node = tree->root;
+	while (node->right)
+		node = node->right;
+	
+	return node->key;
+}
+
+static VALUE splaytree_delete(VALUE self, VALUE key) {
+	splaytree *tree = get_tree_from_self(self);
+	if(!tree->root)
+		return Qnil;
+	
+	return delete(tree, key);
+}
+
+static VALUE splaytree_clear(VALUE self) {
+	splaytree *tree = get_tree_from_self(self);
+	recursively_free_nodes(tree->root);
+	tree->root = NULL;
+	tree->size = 0;
+	
+	return Qnil;
+}
+
+static void splaytree_each_helper(splaytree *tree, splaytree_node *node, void *args) {
+	rb_yield(rb_ary_new3(2, node->key, node->value));
+};
+
+static VALUE splaytree_each(VALUE self) {
+	splaytree *tree = get_tree_from_self(self);
+	splay_each(tree, &splaytree_each_helper, NULL);
+	return self;
+}
+
+static VALUE CSplayTree;
+static VALUE mContainers;
+
+void Init_CSplayTreeMap() {
+	id_compare_operator = rb_intern("<=>");
+	
+	mContainers = rb_define_module("Containers");
+	CSplayTree = rb_define_class_under(mContainers, "CSplayTreeMap", rb_cObject);
+	rb_define_alloc_func(CSplayTree, splaytree_alloc);
+	rb_define_method(CSplayTree, "initialize", splaytree_init, 0);
+	rb_define_method(CSplayTree, "push", splaytree_push, 2);
+	rb_define_method(CSplayTree, "clear", splaytree_clear, 0);
+	rb_define_alias(CSplayTree, "[]=", "push");
+	rb_define_method(CSplayTree, "size", splaytree_size, 0);
+	rb_define_method(CSplayTree, "empty?", splaytree_is_empty, 0);
+	rb_define_method(CSplayTree, "height", splaytree_height, 0);
+	rb_define_method(CSplayTree, "min_key", splaytree_min_key, 0);
+	rb_define_method(CSplayTree, "max_key", splaytree_max_key, 0);
+	rb_define_method(CSplayTree, "each", splaytree_each, 0);
+	rb_define_method(CSplayTree, "get", splaytree_get, 1);
+	rb_define_alias(CSplayTree, "[]", "get");
+	rb_define_method(CSplayTree, "has_key?", splaytree_has_key, 1);
+	rb_define_method(CSplayTree, "delete", splaytree_delete, 1);
+	rb_include_module(CSplayTree, rb_eval_string("Enumerable"));
+}