RubyTrie 1.1 → 2.1

data/ChangeLog

@@ -1,2 +1,4 @@
 1.0 added children and each methods
-1.1 added levenshtein algorithm implementation - inspired from: http://stevehanov.ca/blog/index.php?id=114
+1.1 added levenshtein algorithm implementation - inspired from: http://stevehanov.ca/blog/index.php?id=114
+2.0 completely rewritten the trie implementation to use more optimized data structure. For /usr/share/dict/web2 it takes the memory to about 6Mb from 40Mb. The levenshtein now takes a block and passes in the value but it can be easy extened to return an array.  It also has a glitch where some values are for some reason just false... :|
+2.1 bug fixes, fixing levenshtein search

data/README

@@ -22,6 +22,11 @@ t["goes"] = 2
 t["gone"] = 3
 t["other"] = 4
 
+by default assigning multiple values to the same object will add them to an array.
+t['a'] = 1
+t['a'] = 2 
+will return for t['a'] => [1,2]
+
 t.children("go") => [1,2,3]
 
 t.each("partial key") will yield to the given block all values that are matched by the partial key
@@ -29,8 +34,11 @@ t.each("go") {|v| puts v } => prints 1, 2 & 3
 
 Levenshtein search
 
-t.levenshtein_search("go", 2) - will return all values for the words in the trie that have 1 from the search word
-ex: [["go", 0], ["goes", 2], ["gone", 2]]
+t.levenshtein_search("go", 2) {|value| puts value}  - will print all values for the words in the trie that have 2 distance from the search word
+Eg.
+1
+2
+3
 
 == Bugs
 

data/ext/trie/levenshtein_distance.c

@@ -0,0 +1,77 @@
+/*
+ *  levenshtein_distance.c
+ *  otrie
+ *
+ *  Created by Petrica Ghiurca on 18.03.2011.
+ *  Copyright 2011 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+#include <stdlib.h>
+#include <string.h>  /* for memcmp, memmove */
+#include <stdio.h>
+
+#include "otrie2.h"
+#include "levenshtein_distance.h"
+
+
+void recursive_levenshtein_search(Node* trie, int node_offset, levenshtein_distance_callback cb, int* prev_line, int max_dist, const char* word, int word_length);
+
+void levenshtein_distance(Node* trie, const char* word, int max_distance, levenshtein_distance_callback cb) {
+	int first_line[strlen(word) + 1];
+	int i=0;
+	for(; i < strlen(word) + 1; i++) {
+		first_line[i] = i;
+	}
+	recursive_levenshtein_search(trie->next_sibling, 0, cb, first_line, max_distance, word, strlen(word));
+}
+
+
+int minimum(int* numbers, int len) {
+	int minValue = numbers[0];
+	int i;
+	for(i=1; i<len; i++) {
+		if (numbers[i] < minValue) minValue = numbers[i];
+	}
+	return minValue;
+}
+
+int min3(int a, int b, int c) {
+	int min = a;
+	if (b < min) min = b;
+	if (c < min) min = c;
+	return min;
+}
+
+void recursive_levenshtein_search(Node* trie, int node_offset, levenshtein_distance_callback cb, int* prev_line, int max_dist, const char* word, int word_length) {
+	int cur_line[word_length + 1];
+	int i, insert_cost, replace_cost, delete_cost;
+	
+	cur_line[0] = prev_line[0] + 1;
+	
+	for(i=1; i < word_length + 1; i++) {
+		insert_cost = cur_line[i-1] + 1;
+		delete_cost = prev_line[i] + 1;
+		if (trie->data[node_offset] != word[i-1]) {
+			replace_cost = prev_line[i-1] + 1;
+		} else {
+			replace_cost = prev_line[i-1];
+		}
+		cur_line[i] = min3(insert_cost, delete_cost, replace_cost);
+	}
+	
+	
+	if (cur_line[word_length] <= max_dist && (strlen(trie->data) == (node_offset + 1)) && trie->value != Qnil) {
+		cb(trie, cur_line[word_length]);
+	}
+	
+	if (minimum(cur_line, word_length + 1) <= max_dist) {
+		if (strlen(trie->data) > (node_offset + 1)) 
+			recursive_levenshtein_search(trie, node_offset + 1, cb, cur_line, max_dist, word, word_length);
+		if (trie->first_child != NULL)
+			recursive_levenshtein_search(trie->first_child, 0, cb, cur_line, max_dist, word, word_length);
+		if (trie->next_sibling != NULL)
+			recursive_levenshtein_search(trie->next_sibling, 0, cb, prev_line, max_dist, word, word_length);
+	}
+	
+}

data/ext/trie/levenshtein_distance.h

@@ -0,0 +1,13 @@
+/*
+ *  levenshtein_distance.h
+ *  otrie
+ *
+ *  Created by Petrica Ghiurca on 18.03.2011.
+ *  Copyright 2011 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+#include "otrie2.h"
+
+typedef void (*levenshtein_distance_callback)(Node* node, int length);
+void levenshtein_distance(Node* trie, const char* word, int max_distance, levenshtein_distance_callback cb);

data/ext/trie/otrie2.c

@@ -0,0 +1,161 @@
+/*
+ *  otrie2.c
+ *  otrie
+ *
+ *  Created by Petrica Ghiurca on 18.03.2011.
+ *  Copyright 2011 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+#include <stdlib.h>  /* for malloc, free */
+#include <string.h>  /* for memcmp, memmove */
+#include <stdio.h>
+
+#include "otrie2.h"
+
+Node* new_node() {
+	Node *node = malloc(sizeof(Node));
+	memset(node, 0, sizeof(Node));
+	return node;
+}
+
+Node* new_node_string_len(const char* string, const int len) {
+	Node *node = new_node();
+	node->data = malloc(len+1);
+	strncpy(node->data, string, len);
+	node->data[len] = 0;
+	return node;
+}
+
+Node* new_node_string(const char* string) {
+	Node *node = new_node();
+	int len = strlen(string);
+	node->data = malloc(len+1);
+	strcpy(node->data, string);
+	return node;
+}
+
+void node_update_data(Node* node, const char* string, int len) {
+	char* new_data = malloc(len+1);
+	strncpy(new_data, string, len);
+	new_data[len] = 0;
+	free(node->data);
+	node->data = new_data;
+}
+
+void free_node(Node *node) {
+	if (node->first_child) free_node(node->first_child);
+	if (node->next_sibling) free_node(node->next_sibling);
+	free(node->data);
+	free(node);
+}
+
+void node_insert(Node* node, const char* string, const VALUE value) {
+	int len = strlen(string);
+	Pos *cur = new_pos(node, 0);
+	int i=0;
+	for (; i<len; i++) {
+		pos_next(cur, string + i, true);
+	}
+	cur->node->value = value;
+}
+
+Node* node_find(Node* this, const char* string) {
+	int len = strlen(string);
+	Pos *cur = new_pos(this, 0);
+	int i=0;
+	for(; i<len; i++) {
+		pos_next(cur, string + i, false);
+		if (cur->node == NULL) { return NULL; }
+	}
+	if (strlen(cur->node->data) == cur->offset + 1)
+		return cur->node;
+	return NULL;
+}
+
+Pos* new_pos(Node *node, int offset) {
+	Pos *pos = malloc(sizeof(Pos));
+	pos->node = node;
+	pos->offset = offset;
+	return pos;
+}
+
+Node* pos_find_or_create_child(Pos* this, const char* string, bool down, bool insert) {
+	Node *child = this->node->next_sibling;
+	if (down) child = this->node->first_child;
+
+	Node *last_child = NULL;
+	
+	while(child != NULL && *child->data != *string) { 
+		last_child = child;
+		child = child -> next_sibling; 
+	}
+	if (child == NULL && insert) {
+		child = new_node_string(string);
+		if (!down) {
+			if (this->node -> next_sibling != NULL)  {
+				last_child -> next_sibling = child;
+			} else {
+				this -> node -> next_sibling = child;
+			}
+		} else {
+			if (this -> node -> first_child != NULL) {
+				last_child -> next_sibling = child;
+			} else {
+				this->node -> first_child = child;
+			}
+		}
+	}
+	return child;	
+}
+
+void pos_next(Pos *this, const char* string, bool insert) {
+	if (this -> node -> data == NULL) {
+		this->node = pos_find_or_create_child(this, string, false, insert);
+		this->offset = 0;
+		return;
+	}
+	
+	int len = strlen(this->node->data);
+	if (this -> offset + 1 < len) {
+		if (this -> node->data[this -> offset + 1] == string[0]) {
+			this -> offset++;
+			return;
+		} else {
+			// split paths 
+			// - new child node with old partial content
+			// - new child node with new content			
+			if (insert) {
+				Node *splitChild = new_node_string(this->node->data + this->offset + 1);
+				splitChild -> value = this -> node -> value;
+				Node *newChild = new_node_string(string); 
+        newChild -> value = Qnil;
+				node_update_data(this->node, this->node->data, this->offset + 1);
+				splitChild -> next_sibling = newChild;
+				this->node -> first_child = splitChild;
+        this->node -> value = Qnil;
+				
+				this->node = newChild;
+				this->offset = 0;
+			} else {
+				this -> node = NULL;
+				this -> offset = 0;
+			}
+		}
+	} else {
+		// reached end of data... find a child
+		this->node = pos_find_or_create_child(this, string, true, insert);
+		this->offset = 0;
+		return;
+	}
+}
+
+void node_visit(Node* this, node_iterator func, VALUE context) {
+	func(this, context);
+	if (this->first_child != NULL) {
+		node_visit(this->first_child, func, context);
+	}
+	if (this->next_sibling != NULL) {
+		node_visit(this->next_sibling, func, context);
+	}
+}

data/ext/trie/otrie2.h

@@ -0,0 +1,41 @@
+/*
+ *  otrie2.h
+ *  otrie
+ *
+ *  Created by Petrica Ghiurca on 18.03.2011.
+ *  Copyright 2011 __MyCompanyName__. All rights reserved.
+ *
+ */
+#include <ruby.h>
+
+#define bool int
+#define true 1
+#define false 0
+
+#ifndef TRIE_NODE
+#define TRIE_NODE
+
+typedef struct trie_node {
+	char *data;
+	struct trie_node* first_child;
+	struct trie_node* next_sibling;
+	VALUE value;
+} Node;
+
+typedef struct pos_struct {
+	Node *node;
+	int offset;
+} Pos;
+
+typedef void (*node_iterator)(Node* node, VALUE context);
+
+Node* new_node();
+void free_node(Node*);
+void node_insert(Node* node, const char* string, const VALUE value);
+Node* node_find(Node* this, const char* string);
+
+Pos* new_pos(Node *node, int offset);
+Node* pos_find_or_create_child(Pos* this, const char* string, bool down, bool insert);
+void pos_next(Pos *this, const char* string, bool);
+void node_visit(Node* this, node_iterator func, VALUE context);
+#endif

data/ext/trie/ruby_trie.c

@@ -0,0 +1,199 @@
+/*
+ *  ruby_trie.c
+ *  otrie
+ *
+ *  Created by Petrica Ghiurca on 18.03.2011.
+ *  Copyright 2011 Petrica Ghiurca. All rights reserved.
+ *
+ */
+
+#include <ruby.h>
+#include <stdlib.h>  /* for malloc, free */
+#include <string.h>  /* for memcmp, memmove */
+#include "otrie2.h"
+#include "levenshtein_distance.h"
+
+static VALUE rb_cTrie;
+
+static void count_nodes_callback(Node *trie, VALUE accum);
+static VALUE rb_trie_count_nodes(VALUE self);
+static VALUE rb_trie_allocate(VALUE klass);
+static VALUE rb_trie_get_key(VALUE self, VALUE key);
+static void trie_mark_value(Node*, VALUE);
+static void rb_trie_mark(Node* t);
+static void rb_trie_free(Node * t);
+void tree_collect_values(Node *node, VALUE rary);
+static VALUE rb_trie_find_children(VALUE self, VALUE key);
+static void trie_collect_values_with_yield(Node * node, VALUE context);
+static VALUE rb_trie_find_children_with_block(VALUE self, VALUE key);
+static VALUE rb_trie_set_key_to_value(VALUE self, VALUE key, VALUE value);
+static VALUE rb_trie_levenshtein_search(VALUE self, VALUE word, VALUE max_distance);
+
+// extension init
+void Init_trie() {
+	rb_cTrie = rb_define_class("Trie", rb_cObject);
+	
+	rb_define_alloc_func(rb_cTrie, rb_trie_allocate);
+	
+	int arg_count = 0;
+	//rb_define_method(rb_cTrie, "inspect", rb_trie_inspect, arg_count);
+	rb_define_method(rb_cTrie, "memory", rb_trie_count_nodes, arg_count);
+	
+	arg_count = 1;
+	rb_define_method(rb_cTrie, "[]", rb_trie_get_key, arg_count);
+	// rb_define_method(rb_cTrie, "delete", rb_trie_undef_key, arg_count);
+	rb_define_method(rb_cTrie, "children", rb_trie_find_children, arg_count);
+	rb_define_method(rb_cTrie, "each", rb_trie_find_children_with_block, arg_count);
+	
+	arg_count = 2;
+	rb_define_method(rb_cTrie, "[]=", rb_trie_set_key_to_value, arg_count);
+	// trie.levenshtein_search(word, max_distance)
+	rb_define_method(rb_cTrie, "levenshtein_search", rb_trie_levenshtein_search, arg_count);
+}
+
+static int total_memory; 
+static void count_nodes_callback(Node *trie, VALUE accum) {
+	int len = 0;
+	if (trie->data) len = strlen(trie->data);	
+	rb_big_plus(accum, rb_uint2big(len + sizeof(Node)));
+	total_memory += len + sizeof(Node);
+}
+
+static VALUE rb_trie_count_nodes(VALUE self) {
+	Node *root;
+	Data_Get_Struct(self, Node, root);
+	VALUE accum = rb_uint2big(0);
+	total_memory = 0;
+	node_visit(root, count_nodes_callback, accum);
+	//return accum;
+	return rb_uint2big(total_memory);
+}
+
+static VALUE rb_trie_allocate(VALUE klass) {
+	Node * t = new_node();
+	return Data_Wrap_Struct(klass, rb_trie_mark, rb_trie_free, t);
+}
+				
+static VALUE rb_trie_get_key(VALUE self, VALUE key) {
+	Node * root;
+	Node * node;
+	char * key_cstring;
+	
+	Check_Type(key, T_STRING);
+	key_cstring = StringValuePtr(key);
+	
+	Data_Get_Struct(self, Node, root);
+	
+	node = node_find(root, key_cstring);
+	if (node == NULL) return Qnil;
+	return node->value;
+}
+				
+
+static void trie_mark_value(Node * t, VALUE context) {	
+	rb_gc_mark( t->value );
+}
+
+static void rb_trie_mark(Node* t) {
+	node_visit(t, trie_mark_value, Qnil);
+}
+
+static void rb_trie_free(Node * t) {
+	free_node(t);
+}
+
+void tree_collect_values(Node *node, VALUE rary) {
+	if (node->value != Qnil) {
+		rb_ary_push(rary, node->value);
+	}
+}
+				
+static VALUE rb_trie_find_children(VALUE self, VALUE key) {
+	Node * root;
+	Node * node;
+	char * key_cstring;
+	VALUE rary = rb_ary_new();
+	
+	key_cstring = StringValuePtr(key);
+	Data_Get_Struct(self, Node, root);
+	
+	node = node_find(root, key_cstring);
+	
+	if (node != NULL && node->value != Qnil) {
+		rb_ary_push(rary, node->value);
+	}
+	
+	if (node == NULL || node->first_child == NULL) return rary;
+	
+	node_visit(node->first_child, tree_collect_values, rary);
+	return rary;
+}
+
+static void trie_collect_values_with_yield(Node * node, VALUE context) {
+	if (node->value != Qnil) {
+		rb_yield(node->value);
+	}
+}
+				
+static VALUE rb_trie_find_children_with_block(VALUE self, VALUE key) {
+	Node * root;
+	Node * node;
+	char * key_cstring;
+	VALUE rary = rb_ary_new();
+	
+	key_cstring = StringValuePtr(key);
+	Data_Get_Struct(self, Node, root);
+	
+	node = node_find(root, key_cstring);
+	
+	if (node != NULL && node->value != Qnil) {
+		rb_yield(node->value);
+	}
+	
+	if (node == NULL || node->first_child == NULL) return rary;
+	
+	node_visit(node->first_child, trie_collect_values_with_yield, Qnil);
+	return rary;
+}
+
+
+static VALUE rb_trie_set_key_to_value(VALUE self, VALUE key, VALUE value) {
+	Node * root, *node;
+	char * key_cstring;
+	
+	Check_Type(key, T_STRING);
+	key_cstring = StringValuePtr(key);
+	
+	Data_Get_Struct(self, Node, root);
+	
+	node = node_find(root, key_cstring);
+	if (node == NULL || node -> value == Qnil) {
+    // printf("New node for %s -> %d\n", key_cstring, value);
+		VALUE arr = rb_ary_new();
+		rb_ary_push(arr, value);
+		node_insert(root, key_cstring, arr);
+	} else {
+    // printf("Append value %s to %s -> %d\n", node->data, key_cstring, node->value);
+		rb_ary_push(node->value, value);
+	}
+	
+	return Qnil;
+}
+
+void rb_levensthtein_cb(Node* node, int distance) {
+	if (node->value != Qnil)
+		rb_yield(node->value);
+}
+
+static VALUE rb_trie_levenshtein_search(VALUE self, VALUE word, VALUE max_distance) {
+	Node *root;
+	char *word_cstring;
+
+	Data_Get_Struct(self, Node, root);
+	
+	word_cstring = StringValuePtr(word);
+	
+	levenshtein_distance(root, word_cstring, FIX2INT(max_distance), rb_levensthtein_cb);
+		
+	return Qnil;	
+}

data/ext/trie/t.rb

@@ -1,20 +1,22 @@
 require 'trie'
+require 'rubygems'
 require 'benchmark'
 
 t = Trie.new
 c = 0
+a = 0
 s1 = (Benchmark.measure do 
-  open('/usr/share/dict/words').each_line do |w|
-    t[w.chop] = w.chop
+  open('/usr/share/dict/web2').each_line do |w|
+    t[w.chop]= w
     c += 1
   end
 end)
 
 # %w(gol golas golaster lux xal).each {|w| t[w] = w}
 s2 = (Benchmark.measure do
-    t.levenshtein_search('tread', 2).sort_by {|p| p.last }.each {|p| puts "#{p.last}: #{p.first}"}
+    t.levenshtein_search('food', 1) {|p| puts p}
 end)
 
-puts "#{t.memory/(1024*1024)}Mb, #{c} words"
+puts "#{t.memory/(1024*1024)}Mb, #{c} words, #{a} unique"
 puts s1
 puts s2

data/test/trie_test.rb

@@ -23,10 +23,11 @@ time do
   1.upto(max) do |i|
     t["item #{i}"].class
   end
-  
-  1.upto(max) do |i|
-    t.delete("item #{i}")
-  end
+
+  # not implemented yet  
+  # 1.upto(max) do |i|
+  #   t.delete("item #{i}")
+  # end
 end
 
 
@@ -41,9 +42,9 @@ time do
     t["item #{i}"].class
   end
 
-  1.upto(max) do |i|
-    t.delete("item #{i}")
-  end
+  # 1.upto(max) do |i|
+  #   t.delete("item #{i}")
+  # end
 end
 
 # puts "With a Ruby Trie..."

metadata

@@ -1,21 +1,21 @@
 --- !ruby/object:Gem::Specification 
 name: RubyTrie
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 1
   prerelease: false
   segments: 
+  - 2
   - 1
-  - 1
-  version: "1.1"
+  version: "2.1"
 platform: ruby
 authors: 
-- Matt Freels
 - Petrica Ghiurca
+- Matt Freels
 autorequire: trie
 bindir: bin
 cert_chain: []
 
-date: 2011-01-16 00:00:00 +02:00
+date: 2011-03-21 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -30,7 +30,11 @@ extra_rdoc_files:
 files: 
 - README
 - ChangeLog
-- ext/trie/trie.c
+- ext/trie/levenshtein_distance.h
+- ext/trie/otrie2.h
+- ext/trie/levenshtein_distance.c
+- ext/trie/otrie2.c
+- ext/trie/ruby_trie.c
 - ext/trie/extconf.rb
 - ext/trie/t.rb
 - lib/ruby_trie.rb

data/ext/trie/trie.c

@@ -1,408 +0,0 @@
-#include <stdlib.h>  /* for malloc, free */
-#include <string.h>  /* for memcmp, memmove */
-#include "ruby.h"
-
-// typdefs!
-typedef enum { false = 0, true} bool;
-
-typedef struct node {
-	char character;
-	VALUE value;
-	struct node * first_child;
-	struct node * next_sibling;
-} trie_node;
-
-static VALUE rb_cTrie;
-
-// =========================
-// = function declarations =
-// =========================
-
-//trie implementation
-static trie_node * trie_node_for_key(trie_node * root, char * key, bool create_missing_nodes);
-static trie_node * trie_sibling_for_char(trie_node * node, char ch);
-static trie_node * trie_add_sibling_for_char(trie_node * node, char ch);
-static trie_node * trie_new_node_with_char(char ch);
-static trie_node * trie_new_node();
-static VALUE rb_trie_find_children(VALUE self, VALUE key);
-static VALUE rb_trie_find_children_with_block(VALUE self, VALUE key);
-static VALUE rb_trie_levenshtein_search(VALUE self, VALUE word, VALUE max_distance);
-static void trie_collect_values(void * t, VALUE prary);
-static void trie_collect_values_with_yield(void * t);
-static void trie_traverse(trie_node * trie, void (*lambda_func)(void *));
-static void trie_traverse_with_context(trie_node * trie, VALUE context, void (*lambda_func)(void *, VALUE));
-static void free_trie(trie_node * trie);
-static void count_nodes_callback(void *n, VALUE accum);
-static VALUE rb_trie_count_nodes(VALUE self);
-static recursive_levenshtein_search(trie_node* trie, VALUE rary, int* prev_line, int max_dist, char* word, int word_length);
-// int print_arr(char c, int* arr, int len);
-
-
-// ========================
-// = function definitions =
-// ========================
-
-// instance methods
-static VALUE rb_trie_get_key(VALUE self, VALUE key) {
-	trie_node * root;
-	trie_node * node;
-	char * key_cstring;
-	
-	//Check_Type(key, T_STRING);
-	key_cstring = StringValuePtr(key);
-
-	Data_Get_Struct(self, trie_node, root);
-	
-	node = trie_node_for_key(root, key_cstring, false);
-	if (node == NULL) return Qnil;
-	return node->value;
-}
-
-static VALUE rb_trie_set_key_to_value(VALUE self, VALUE key, VALUE value) {
-	trie_node * root;
-	trie_node * node;
-	char * key_cstring;
-	
-	//Check_Type(key, T_STRING);
-	key_cstring = StringValuePtr(key);
-
-	Data_Get_Struct(self, trie_node, root);
-
-	node = trie_node_for_key(root, key_cstring, true);	
-	node->value = value;
-	
-	return Qnil;
-}
-
-static uint mem_count = 0;
-
-static void count_nodes_callback(void *n, VALUE accum) {
-  trie_node *node = (trie_node*)n;
-  // rb_big_plus(accum, rb_uint2big(sizeof(*node)));
-  mem_count+=sizeof(*node);
-}
-
-static VALUE rb_trie_count_nodes(VALUE self) {
-  trie_node *root;
-  Data_Get_Struct(self, trie_node, root);
-  VALUE accum = rb_uint2big(0);
-  mem_count = 0;
-  trie_traverse_with_context(root, accum, count_nodes_callback);
-  return rb_uint2big(mem_count);
-}
-
-static VALUE rb_trie_undef_key(VALUE self, VALUE key) {
-	trie_node * root, * node, * prev, * next;
-	VALUE return_value;	
-	char * key_cstring;
-	int steps;
-	int i;
-	
-	//Check_Type(key, T_STRING);
-	key_cstring = StringValuePtr(key);
-	
-	Data_Get_Struct(self, trie_node, root);
-	next = root;
-	node = NULL;
-	prev = NULL;
-
-	steps = strlen(key_cstring);
-	
-	for (i = 0; i < steps; i++) {
-		if (next == NULL) return Qnil;
-		
-		while(next->character != key_cstring[i]) {
-			if (next == NULL) return Qnil;
-			next = next->next_sibling;
-		}
-		prev = node;
-		node = next;
-		next = node->first_child;
-	}
-	
-	return_value = node->value;
-	node->value = Qnil;
-	
-	if (node->first_child == NULL) { //node has no children. we can delete it.
-		if (prev == NULL)  {
-			//printf("should delete root");
-		} else if (prev->first_child == node) {
-			prev->first_child = node->next_sibling;
-			free(node);
-		} else if (prev->next_sibling == node) {
-			prev->next_sibling = node->next_sibling;
-			free(node);
-		}
-	}
-	
-	return return_value;
-}
-
-// garbage collection and allocation
-static void trie_mark_value(void * t) {	
-	rb_gc_mark( ((trie_node *)t)->value );
-}
-
-static void rb_trie_mark(trie_node * t) {
-	trie_traverse(t, trie_mark_value);
-}
-
-static void rb_trie_free(trie_node * t) {
-	free_trie(t);
-}
-
-static VALUE rb_trie_allocate (VALUE klass) {
-	trie_node * t = trie_new_node();
-
-	return Data_Wrap_Struct(klass, rb_trie_mark, rb_trie_free, t);
-}
-
-// extension init
-void Init_trie() {
-	rb_cTrie = rb_define_class("Trie", rb_cObject);
-
-	rb_define_alloc_func (rb_cTrie, rb_trie_allocate);
-
-	int arg_count = 0;
-	//rb_define_method(rb_cTrie, "inspect", rb_trie_inspect, arg_count);
-	rb_define_method(rb_cTrie, "memory", rb_trie_count_nodes, arg_count);
-	
-	arg_count = 1;
-	rb_define_method(rb_cTrie, "[]", rb_trie_get_key, arg_count);
-	rb_define_method(rb_cTrie, "delete", rb_trie_undef_key, arg_count);
-	rb_define_method(rb_cTrie, "children", rb_trie_find_children, arg_count);
-	rb_define_method(rb_cTrie, "each", rb_trie_find_children_with_block, arg_count);
-
-	arg_count = 2;
-	rb_define_method(rb_cTrie, "[]=", rb_trie_set_key_to_value, arg_count);
-	// trie.levenshtein_search(word, max_distance)
-	rb_define_method(rb_cTrie, "levenshtein_search", rb_trie_levenshtein_search, arg_count);
-}
-
-
-// =======================
-// = trie implementation =
-// =======================
-
-static trie_node * trie_node_for_key(trie_node * root, char * key, bool create_missing_nodes) {		
-	int steps, i;
-	trie_node * next, * node;
-
-	steps = strlen(key);
-	next = root;
-
-	for (i = 0; i < steps; i++) {
-		if (next == NULL) {
-			if (create_missing_nodes) {
-				node->first_child = trie_new_node();
-				next = node->first_child;
-			}
-			else return NULL;
-		}
-
-		node = trie_sibling_for_char(next, key[i]);
-
-		if (node == NULL) {
-			if (create_missing_nodes) {
-				node = trie_add_sibling_for_char(next, key[i]);
-			}	
-			else return NULL;
-		}
-
-		next = node->first_child;
-	}	
-		
-	return node;    
-}
-
-static void trie_collect_values(void * t, VALUE rary) {	
-	trie_node *node = (trie_node*)t;
-	if (node->value != Qnil) {
-		rb_ary_push(rary, node->value);
-	}
-}
-
-static void trie_collect_values_with_yield(void * t) {	
-	trie_node *node = (trie_node*)t;
-	if (node->value != Qnil) {
-		// rb_ary_push(rary, node->value);
-		rb_yield(node->value);
-	}
-}
-
-static VALUE rb_trie_find_children(VALUE self, VALUE key) {
-	trie_node * root;
-	trie_node * node;
-	char * key_cstring;
-	VALUE rary = rb_ary_new();
-
-	key_cstring = StringValuePtr(key);
-	Data_Get_Struct(self, trie_node, root);
-
-	node = trie_node_for_key(root, key_cstring, false);
-	
-	if (node != NULL && node->value != Qnil) {
-		rb_ary_push(rary, node->value);
-	}
-	
-	if (node == NULL || node->first_child == NULL) return rary;
-
-	trie_traverse_with_context(node->first_child, rary, trie_collect_values);
-	return rary;
-}
-
-
-static VALUE rb_trie_find_children_with_block(VALUE self, VALUE key) {
-	trie_node * root;
-	trie_node * node;
-	char * key_cstring;
-	VALUE rary = rb_ary_new();
-
-	key_cstring = StringValuePtr(key);
-	Data_Get_Struct(self, trie_node, root);
-
-	node = trie_node_for_key(root, key_cstring, false);
-	
-	if (node != NULL && node->value != Qnil) {
-		rb_yield(node->value);
-	}
-	
-	if (node == NULL || node->first_child == NULL) return rary;
-
-	trie_traverse(node->first_child, trie_collect_values_with_yield);
-	return rary;
-}
-
-static VALUE rb_trie_levenshtein_search(VALUE self, VALUE word, VALUE max_distance) {
-  trie_node *root;
-  trie_node *node;
-  char *word_cstring;
-  VALUE rary = rb_ary_new();
-  int i=0;
-  
-  Data_Get_Struct(self, trie_node, root);
-  
-  word_cstring = StringValuePtr(word);
-
-  int first_line[strlen(word_cstring) + 1];
-  for(; i < strlen(word_cstring) + 1; i++) {
-    first_line[i] = i;
-  }
-  // print_arr('R', first_line, strlen(word_cstring)+1);
-  recursive_levenshtein_search(root->next_sibling, rary, first_line, FIX2INT(max_distance), word_cstring, strlen(word_cstring));
-
-  return rary;
-}
-
-int minimum(int* numbers, int len) {
-  int minValue = numbers[0];
-  int i;
-  for(i=1; i<len; i++) {
-    if (numbers[i] < minValue) minValue = numbers[i];
-  }
-  return minValue;
-}
-
-int min3(int a, int b, int c) {
-  int min = a;
-  if (b < min) min = b;
-  if (c < min) min = c;
-  return min;
-}
-
-static recursive_levenshtein_search(trie_node* trie, VALUE rary, int* prev_line, int max_dist, char* word, int word_length) {
-  int cur_line[word_length + 1];
-  int i,j, insert_cost, replace_cost, delete_cost;
-  VALUE carr;
-
-  cur_line[0] = prev_line[0] + 1;
-
-  for(i=1; i < word_length + 1; i++) {
-    insert_cost = cur_line[i-1] + 1;
-    delete_cost = prev_line[i] + 1;
-    if (trie->character != word[i-1]) {
-      replace_cost = prev_line[i-1] + 1;
-    } else {
-      replace_cost = prev_line[i-1];
-    }
-    cur_line[i] = min3(insert_cost, delete_cost, replace_cost);
-  }
-
-
-  if (cur_line[word_length] <= max_dist && trie->value != Qnil) {
-    carr = rb_ary_new();
-    rb_ary_push(carr, trie->value);
-    rb_ary_push(carr, INT2FIX(cur_line[word_length]));
-    rb_ary_push(rary, carr);
-  }
-
-  if (minimum(cur_line, word_length + 1) <= max_dist) {
-    if (trie->first_child != NULL)
-      recursive_levenshtein_search(trie->first_child, rary, cur_line, max_dist, word, word_length);
-    if (trie->next_sibling != NULL)
-      recursive_levenshtein_search(trie->next_sibling, rary, prev_line, max_dist, word, word_length);
-  }
-}
-
-static trie_node * trie_sibling_for_char(trie_node * node, char ch) {
-	while(true) {
-		if (node == NULL) return NULL;
-
-		if (node->character == ch) return node;
-
-		node = node->next_sibling;
-	}
-	return node;
-}
-
-static trie_node * trie_add_sibling_for_char(trie_node * node, char ch) {
-	trie_node * current_next;
-
-	current_next = node->next_sibling;
-	node->next_sibling = trie_new_node_with_char(ch);
-	node->next_sibling->next_sibling = current_next;
-
-	return node->next_sibling;
-}
-
-static trie_node * trie_new_node_with_char(char ch) {
-	trie_node * trie;
-	trie = malloc(sizeof(trie_node));
-	trie->character = ch;
-	trie->value = Qnil;
-	trie->first_child = NULL;
-	trie->next_sibling = NULL;
-	return trie;
-}
-
-static trie_node * trie_new_node() {
-	return trie_new_node_with_char('s'); //insert most common starting letter here.
-}
-
-static void trie_traverse(trie_node * trie, void (* lambda_func)(void *)) {
-	if (trie->next_sibling != NULL) {
-		trie_traverse(trie->next_sibling, lambda_func);
-	}
-
-	if (trie->first_child != NULL) {
-		trie_traverse(trie->first_child, lambda_func);
-	}
-
-	lambda_func(trie);
-}
-
-static void trie_traverse_with_context(trie_node * trie, VALUE context, void (*lambda_func)(void *, VALUE)) {
-	if (trie->next_sibling != NULL) {
-		trie_traverse_with_context(trie->next_sibling, context, lambda_func);
-	}
-
-	if (trie->first_child != NULL) {
-		trie_traverse_with_context(trie->first_child, context, lambda_func);
-	}
-
-	lambda_func(trie, context);
-}
-
-static void free_trie(trie_node * trie) {
-	trie_traverse(trie, free);
-}