algorithms 0.2.0 → 0.3.0

data/History.txt

@@ -1,3 +1,7 @@
+=== April 3, 2009
+
+	* Finished C refactorization of SplayTree
+
 === March 28, 2009
 
 	* Implemented SplayTree in C

data/Manifest

@@ -1,3 +1,7 @@
+History.txt
+Manifest
+README.markdown
+Rakefile
 algorithms.gemspec
 benchmarks/deque.rb
 benchmarks/sorts.rb
@@ -8,10 +12,9 @@ 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.rb
 lib/algorithms/search.rb
 lib/algorithms/sort.rb
-lib/algorithms.rb
 lib/containers/deque.rb
 lib/containers/heap.rb
 lib/containers/kd_tree.rb
@@ -22,16 +25,15 @@ 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_expected_out.txt
+spec/kd_test_in.txt
 spec/kd_tree_spec.rb
+spec/map_gc_mark_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

@@ -31,6 +31,7 @@ Done so far:
 		* Splay Trees        Containers::SplayTreeMap, Containers::CSplayTreeMap (C extension), Containers::RubySplayTreeMap
 		* Tries              Containers::Trie
 		* Suffix Array       Containers::SuffixArray
+		* kd Tree   				 Containers::KDTree
 
 		* Search algorithms
 		  - Binary Search            Algorithms::Search.binary_search

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.2.0"
+  p.version              = "0.3.0"
   p.runtime_dependencies = []
 end
 

data/algorithms.gemspec

@@ -2,16 +2,16 @@
 
 Gem::Specification.new do |s|
   s.name = %q{algorithms}
-  s.version = "0.2.0"
+  s.version = "0.3.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-03-29}
+  s.date = %q{2009-11-16}
   s.description = %q{A library of algorithms and containers.}
   s.email = %q{kanwei@gmail.com}
   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.extra_rdoc_files = ["README.markdown", "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.rb", "lib/algorithms/search.rb", "lib/algorithms/sort.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"]
+  s.files = ["History.txt", "Manifest", "README.markdown", "Rakefile", "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", "lib/algorithms.rb", "lib/algorithms/search.rb", "lib/algorithms/sort.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", "spec/deque_gc_mark_spec.rb", "spec/deque_spec.rb", "spec/heap_spec.rb", "spec/kd_expected_out.txt", "spec/kd_test_in.txt", "spec/kd_tree_spec.rb", "spec/map_gc_mark_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.has_rdoc = true
   s.homepage = %q{http://rubyforge.org/projects/algorithms/}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Algorithms", "--main", "README.markdown"]

data/benchmarks/treemaps.rb

@@ -1,20 +1,19 @@
 $: << File.join(File.expand_path(File.dirname(__FILE__)), '../lib')
 require 'algorithms'
-include Algorithms
+include Containers
 
 require 'rubygems'
 require 'rbench'
 
-RBench.run(10) do
+RBench.run(2) do
   trees = %w(hash rbtree splaytree)
   trees.each { |tree| self.send(:column, tree.intern) }
   
-  rbtree = Containers::RBTreeMap.new
-  splaytree = Containers::SplayTreeMap.new
+  rbtree = RBTreeMap.new
+  splaytree = SplayTreeMap.new
   hash = Hash.new
   
-  random_array = Array.new(10000) { |i| rand(i) }
-  num = 1000
+  random_array = Array.new(300000) { |i| rand(i) }
   
   report "Insertion" do
     rbtree { random_array.each_with_index  { |x,index| rbtree[index] = x } }
@@ -22,15 +21,31 @@ RBench.run(10) do
     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) } }
+  report "has_key? (linear order)" do
+    rbtree { random_array.each { |n| rbtree.has_key?(n) } }
+    splaytree { random_array.each { |n| splaytree.has_key?(n) } }
+    hash { random_array.each { |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 } }
+    
+    # a1, a2, a3 = [], [], []
+    # rbtree.each { |k, v| a1 << k }
+    # splaytree.each { |k, v| a2 << k }
+    # hash.sort.each { |k, v| a3 << k }
+    # 
+    # puts "Lookup correct" if a1 == a2 && a1 == a3
   end
+  
+  report "Random lookups in a smaller subset" do
+    select_subset = random_array[0..random_array.size/20] # 5%
+    size = select_subset.size
+    rbtree { 10000.times { rbtree[ select_subset[rand(size)] ] } }
+    splaytree { 10000.times { splaytree[ select_subset[rand(size)] ] } }
+    hash { 10000.times { hash[ select_subset[rand(size)] ] } }
+  end
+  
 end

data/ext/containers/rbtree_map/rbtree.c

@@ -22,6 +22,11 @@ typedef struct {
 	rbtree_node *root;
 } rbtree;
 
+typedef struct struct_ll_node {
+	rbtree_node *node;
+	struct struct_ll_node *next;
+} ll_node;
+
 static void recursively_free_nodes(rbtree_node *node) {
 	if(node) {
 		recursively_free_nodes(node->left);
@@ -292,8 +297,8 @@ static int rbtree_compare_function(VALUE a, VALUE b) {
 		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) {
+	if (TYPE(a) == T_STRING && rb_obj_is_kind_of(a, rb_cString) &&
+            TYPE(b) == T_STRING && rb_obj_is_kind_of(b, rb_cString)) {
 		return rb_str_cmp(a, b);
 	}
 	return FIX2INT(rb_funcall((VALUE) a, id_compare_operator, 1, (VALUE) b));
@@ -304,19 +309,39 @@ static VALUE rbtree_init(VALUE self)
 	return self;
 }
 
-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) {
+	ll_node *current, *new, *last, *old;
 	if (ptr) {
 		rbtree *tree = ptr;
-		recursively_mark_nodes(tree->root);
+		
+		if (tree->root) {
+			current = ALLOC(ll_node);
+			last = current;
+			current->node = tree->root;
+			current->next = NULL;
+
+			while(current) {
+				rb_gc_mark(current->node->key);
+				rb_gc_mark(current->node->value);
+				if (current->node->left) {
+					new = ALLOC(ll_node);
+					new->node = current->node->left;
+					new->next = NULL;
+					last->next = new;
+					last = new;
+				} 
+				if (current->node->right) {
+					new = ALLOC(ll_node);
+					new->node = current->node->right;
+					new->next = NULL;
+					last->next = new;
+					last = new;
+				}
+				old = current;
+				current = current->next;
+				free(old);
+			}
+		}
 	}
 }
 

data/ext/containers/splaytree_map/splaytree.c

@@ -1,19 +1,29 @@
 #include "ruby.h"
 
+#define node_size(x) (((x)==NULL) ? 0 : ((x)->size))
+
+/* 	Using http://www.link.cs.cmu.edu/link/ftp-site/splaying/top-down-size-splay.c as reference,
+	written by D. Sleator <sleator@cs.cmu.edu>, January 1994.
+*/
+
 typedef struct struct_splaytree_node {
 	VALUE key;
 	VALUE value;
+	int size;
 	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;
 
+typedef struct struct_ll_node {
+	splaytree_node *node;
+	struct struct_ll_node *next;
+} ll_node;
+
 static void recursively_free_nodes(splaytree_node *node) {
 	if(node) {
 		recursively_free_nodes(node->left);
@@ -29,55 +39,75 @@ static splaytree* get_tree_from_self(VALUE self) {
 	return tree;
 }
 
-static void splay(splaytree *tree, VALUE key) {
-	int cmp, cmp2;
-	splaytree_node *l, *r, *t, *y;
+static splaytree_node* splay(splaytree *tree, splaytree_node *n, VALUE key) {
+	int cmp, cmp2, root_size, l_size, r_size;
+	splaytree_node N;
+	splaytree_node *l, *r, *y;
 	
-	l = tree->header;
-	r = tree->header;
-	t = tree->root;
+	if (!n) return n;
 	
-	tree->header->left = NULL;
-	tree->header->right = NULL;
+	N.left = N.right = NULL;
+	l = r = &N;
+	root_size = node_size(n);
+	l_size = r_size = 0;
 	
 	while(1) {
-		cmp = tree->compare_function(key, t->key);
+		cmp = tree->compare_function(key, n->key);
 		if (cmp == -1) {
-			if (!(t->left)) break;
-			cmp2 = tree->compare_function(key, t->left->key);
+			if (!n->left) break;
+			cmp2 = tree->compare_function(key, n->left->key);
 			if (cmp2 == -1) {
-				y = t->left;
-				t->left = y->right;
-				y->right = t;
-				t = y;
-          		if (!(t->left)) break;
+				y = n->left;
+				n->left = y->right;
+				y->right = n;
+				n->size = node_size(n->left) + node_size(n->right) + 1;
+				n = y;
+          		if (!n->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);
+			r->left = n;
+			r = n;
+			n = n->left;
+			r_size += 1 + node_size(r->right);
+		} else if (cmp == 1) {
+			if (!n->right) break;
+			cmp2 = tree->compare_function(key, n->right->key);
 			if (cmp2 == 1) {
-				y = t->right;
-				t->right = y->left;
-				y->left = t;
-				t = y;
-          		if (!(t->right)) break;
+				y = n->right;
+				n->right = y->left;
+				y->left = n;
+				n->size = node_size(n->left) + node_size(n->right) + 1;
+				n = y;
+          		if (!n->right) break;
 			}
-			l->right = t;
-			l = t;
-			t = t->right;
+			l->right = n;
+			l = n;
+			n = n->right;
+			l_size += 1 + node_size(l->left);
 		} else {
 			break;
 		}
 	}
-	l->right = t->left;
-	r->left = t->right;
-	t->left = tree->header->right;
-    t->right = tree->header->left;
-	tree->root = t;
+	
+	l_size += node_size(n->left);
+    r_size += node_size(n->right);
+    n->size = l_size + r_size + 1;
+    l->right = r->left = NULL;
+
+	for (y = N.right; y != NULL; y = y->right) {
+		y->size = l_size;
+		l_size -= 1 + node_size(y->left);
+	}
+	for (y = N.left; y != NULL; y = y->left) {
+		y->size = r_size;
+		r_size -= 1 + node_size(y->right);
+	}
+	
+	l->right = n->left;
+	r->left = n->right;
+	n->left = N.right;
+    n->right = N.left;
+	
+	return n;
 }
 
 static int height(splaytree_node *h) {
@@ -95,8 +125,6 @@ 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;
 }
 
@@ -109,44 +137,46 @@ static splaytree_node* create_node(VALUE key, VALUE value) {
 	return new_node;
 }
 
-static void insert(splaytree *tree, VALUE key, VALUE value) {
+static splaytree_node* insert(splaytree *tree, splaytree_node *n, 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;
+	if (n) {
+		n = splay(tree, n, key);
+		cmp = tree->compare_function(key, n->key);
+		if (cmp == 0) {
+			n->value = value;
+			return n;
+		}
 	}
-	
-	splay(tree, key);
-	cmp = tree->compare_function(key, tree->root->key);
-	if (cmp == 0) {
-		tree->root->value = value;
-		return;
+	new_node = create_node(key, value);
+	if (!n) {
+		new_node->left = new_node->right = NULL;
 	} 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;
+		cmp = tree->compare_function(key, n->key);
+		if (cmp < 0) {
+			new_node->left = n->left;
+			new_node->right = n;
+			n->left = NULL;
+			n->size = 1 + node_size(n->right);
+		} else {
+			new_node->right = n->right;
+			new_node->left = n;
+			n->right = NULL;
+			n->size = 1 + node_size(n->left);
 		}
-		tree->root = new_node;
-		tree->size += 1;
 	}
+	new_node->size = 1 + node_size(new_node->left) + node_size(new_node->right);
+	return new_node;
 }
 
 static VALUE get(splaytree *tree, VALUE key) {
 	int cmp;
+	
 	if (!tree->root)
 		return Qnil;
-	
-	splay(tree, key);
+		
+	tree->root = splay(tree, tree->root, key);
 	cmp = tree->compare_function(key, tree->root->key);
 	if (cmp == 0) {
 		return tree->root->value;
@@ -154,29 +184,28 @@ static VALUE get(splaytree *tree, VALUE key) {
 	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);
+static splaytree_node* delete(splaytree *tree, splaytree_node *n, VALUE key, VALUE *deleted) {
+	int cmp, tsize;
+	splaytree_node *x;
+	
+	tsize = n->size;
+	n = splay(tree, n, key);
+	cmp = tree->compare_function(key, n->key);
 	if (cmp == 0) {
-		deleted = tree->root->value;
-		deleted_root = tree->root;
-		if (!(tree->root->left)) {
-			tree->root = tree->root->right;
+		*deleted = n->value;
+		if (!n->left) {
+			x = n->right;
 		} else {
-			x = tree->root->right;
-			tree->root = tree->root->left;
-			splay(tree, key);
-			tree->root->right = x;
+			x = splay(tree, n->left, key);
+			x->right = n->right;
 		}
-		free(deleted_root);
-		tree->size -= 1;
-		return deleted;
+		free(n);
+		if (x) {
+			x->size = tsize-1;
+		}
+		return x;
 	}
-	return Qnil;
+	return n;
 }
 
 static splaytree* splaytree_each_node(splaytree *tree, splaytree_node *node, void (*each)(splaytree *tree_, splaytree_node *node_, void* args), void* arguments) {
@@ -211,8 +240,8 @@ static int splaytree_compare_function(VALUE a, VALUE b) {
 		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) {
+	if (TYPE(a) == T_STRING && rb_obj_is_kind_of(a, rb_cString) &&
+            TYPE(b) == T_STRING && rb_obj_is_kind_of(b, rb_cString)) {
 		return rb_str_cmp(a, b);
 	}
 	return FIX2INT(rb_funcall((VALUE) a, id_compare_operator, 1, (VALUE) b));
@@ -223,19 +252,39 @@ 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) {
+	ll_node *current, *new, *last, *old;
 	if (ptr) {
 		splaytree *tree = ptr;
-		recursively_mark_nodes(tree->root);
+		
+		if (tree->root) {
+			current = ALLOC(ll_node);
+			last = current;
+			current->node = tree->root;
+			current->next = NULL;
+
+			while(current) {
+				rb_gc_mark(current->node->key);
+				rb_gc_mark(current->node->value);
+				if (current->node->left) {
+					new = ALLOC(ll_node);
+					new->node = current->node->left;
+					new->next = NULL;
+					last->next = new;
+					last = new;
+				} 
+				if (current->node->right) {
+					new = ALLOC(ll_node);
+					new->node = current->node->right;
+					new->next = NULL;
+					last->next = new;
+					last = new;
+				}
+				old = current;
+				current = current->next;
+				free(old);
+			}
+		}
 	}
 }
 
@@ -243,7 +292,6 @@ static void splaytree_free(void *ptr) {
 	if (ptr) {
 		splaytree *tree = ptr;
 		recursively_free_nodes(tree->root);
-		free(tree->header);
 		free(tree);
 	}
 }
@@ -255,7 +303,7 @@ static VALUE splaytree_alloc(VALUE klass) {
 
 static VALUE splaytree_push(VALUE self, VALUE key, VALUE value) {
 	splaytree *tree = get_tree_from_self(self);
-	insert(tree, key, value);
+	tree->root = insert(tree, tree->root, key, value);
 	return value;
 }
 
@@ -266,7 +314,8 @@ static VALUE splaytree_get(VALUE self, VALUE key) {
 
 static VALUE splaytree_size(VALUE self) {
 	splaytree *tree = get_tree_from_self(self);
-	return INT2NUM(tree->size);
+	if(!tree->root) { return INT2NUM(0); }
+	return INT2NUM(tree->root->size);
 }
 
 static VALUE splaytree_is_empty(VALUE self) {
@@ -317,19 +366,19 @@ static VALUE splaytree_max_key(VALUE self) {
 }
 
 static VALUE splaytree_delete(VALUE self, VALUE key) {
+	VALUE deleted = Qnil;
 	splaytree *tree = get_tree_from_self(self);
 	if(!tree->root)
 		return Qnil;
 	
-	return delete(tree, key);
+	tree->root = delete(tree, tree->root, key, &deleted);
+	return deleted;
 }
 
 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;
 }