amorim-algorithms 0.6.1

data/benchmarks/treemaps.rb

@@ -0,0 +1,51 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '../lib')
+require 'algorithms'
+include Containers
+
+require 'rubygems'
+require 'rbench'
+
+RBench.run(2) do
+  trees = %w(hash rbtree splaytree)
+  trees.each { |tree| self.send(:column, tree.intern) }
+  
+  rbtree = RBTreeMap.new
+  splaytree = SplayTreeMap.new
+  hash = Hash.new
+  
+  random_array = Array.new(300000) { |i| rand(i) }
+  
+  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? (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/algorithms/string/extconf.rb

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

data/ext/algorithms/string/string.c

@@ -0,0 +1,68 @@
+#include "ruby.h"
+
+long min_three(long a, long b, long c) {
+	long min = a;
+	if (b < min)
+		min = b;
+	if( c < min)
+		min = c;
+	return min;
+}
+
+long levenshtein_distance(VALUE str1, VALUE str2) {
+	long i, j, s1_len, s2_len, *d;
+	char * s = RSTRING_PTR(str1);
+	char * t = RSTRING_PTR(str2);
+	s1_len = RSTRING_LEN(str1);
+	s2_len = RSTRING_LEN(str2);
+	
+	if (s1_len == 0) {
+		return s2_len;
+	} else if (s2_len == 0) {
+		return s1_len;
+	}
+	
+	// We need one extra col and row for the matrix for starting values
+	s1_len++;
+	s2_len++;
+	
+	d = xmalloc(sizeof(typeof(d)) * s1_len * s2_len);
+	
+	for (i = 0; i < s1_len; i++) {
+		d[i] = i; // d[i, 0] = i
+	}
+	for (j = 0; j < s2_len; j++) {
+		d[j*s1_len] = j; // d[0, j] = j
+	}
+	
+	for (i = 1; i < s1_len; i++) {
+		for (j = 1; j < s2_len; j++) {
+			if (s[i-1] == t[j-1]) {
+				d[j * s1_len + i] = d[(j-1) * s1_len + (i-1)];
+			} else {
+				d[j * s1_len + i] = 1 + min_three(
+					d[j * s1_len + (i-1)],
+					d[(j-1) * s1_len + i],
+					d[(j-1) * s1_len + (i-1)]
+				);
+			}
+		}
+	}
+	i = d[s1_len * s2_len -1];
+	xfree(d);
+	return i;
+}
+
+static VALUE lev_dist(VALUE self, VALUE str1, VALUE str2) {
+	return LONG2FIX(levenshtein_distance( str1, str2 ));
+}
+
+static VALUE mAlgorithms;
+static VALUE mString;
+
+void Init_CString() {	
+	mAlgorithms = rb_define_module("Algorithms");
+	mString = rb_define_module_under(mAlgorithms, "String");
+	rb_define_singleton_method(mString, "levenshtein_dist", lev_dist, 2);
+}
+

data/ext/containers/bst/bst.c

@@ -0,0 +1,247 @@
+#include "ruby.h"
+
+typedef struct struct_bst_node {
+	VALUE key;
+	VALUE value;
+	struct struct_bst_node *left;
+	struct struct_bst_node *right;
+	struct struct_bst_node *parent;
+} bst_node;
+
+typedef struct struct_bst {
+	bst_node *root;
+	int (*compare_function)(VALUE key1, VALUE key2);
+	unsigned int size; 
+} bst;
+
+static VALUE bst_initialize(VALUE self) {
+	return self;
+}
+
+static bst* get_bst_from_self(VALUE self) {
+	bst *tree;
+	Data_Get_Struct(self, bst, tree);
+	return tree;
+}
+
+static bst* bst_each_node(bst *tree, bst_node *node, void (*each)(bst *tree_, bst_node *node_, void* args), void* arguments) {
+	if (!node)
+		return NULL;
+	
+		if (node->left)
+			bst_each_node(tree, node->left, each, arguments);
+		
+		(*each)(tree, node, arguments);
+		
+		if (node->right)
+			bst_each_node(tree, node->right, each, arguments);
+	return tree;
+}
+
+static bst* bst_each(bst *tree, void (*each)(bst *tree, bst_node *node, void *args), void* arguments) {
+	if (tree->root)
+		bst_each_node(tree, tree->root, each, arguments);
+	return tree;
+}
+
+static VALUE id_compare_operator;
+
+static int bst_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 && 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));
+}
+
+static void insert_element(bst *tree, bst_node **t,bst_node *newElement) {
+	int cmp;
+	bst_node *y = NULL;
+	bst_node *x = *t;
+	while (x != NULL) {
+		y = x;
+		cmp = tree->compare_function(newElement->key, x->key);
+		if (cmp < 0) x = x->left;
+		else x = x->right;
+	}
+	newElement->parent = y;
+	if (y == NULL) *t = newElement;
+	else {
+		cmp = tree->compare_function(newElement->key, y->key);
+		if (cmp < 0)
+		 	y->left = newElement;
+		else 
+			y->right = newElement;
+	}
+}
+
+
+static bst_node* create_node(VALUE key_value,VALUE value) {
+	bst_node *new_node = ALLOC(bst_node);
+	new_node->value = value;
+	new_node->key = key_value;
+	new_node->left = NULL;
+	new_node->right = NULL;
+	new_node->parent = NULL;
+	return new_node;	 
+}
+
+static bst_node* tree_minimum (bst_node *tree) {
+	bst_node *x = tree;
+	while (x->left) x = x->left;
+	return x;
+}
+
+static bst_node* tree_maximum (bst_node *tree) {
+	bst_node *x = tree;
+	while (x->right) x = x->right;
+	return x;
+}
+
+static bst_node* node_successor (bst_node *tree,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;
+}
+
+
+static bst_node* delete_node (bst_node **tree,bst_node *tobeDeleted) {
+	bst_node *y,*x;
+
+	if ((tobeDeleted->left == NULL) || (tobeDeleted->right == NULL)) y = tobeDeleted;
+	else y = node_successor(*tree,tobeDeleted);
+
+	if (y->left) x = y->left;
+	else x = y->right;
+
+	if (x) x->parent = y->parent;
+
+	if (y->parent == NULL) {
+		*tree = 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;
+}
+
+static bst_node* search_node(bst *tree, bst_node *node, VALUE key) {
+	bst_node *x = node;
+	int cmp;
+	
+	while(x) {
+		cmp = tree->compare_function(key, x->key);
+		if (cmp == 0) return x;
+		else if (cmp < 0) { x = x->left; }
+		else { x = x->right; }
+	}
+	return NULL;
+}
+
+static void recursively_mark_nodes(bst_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 bst_mark(bst *tree) {
+	if (tree) {
+		recursively_mark_nodes(tree->root);
+	}
+}
+
+static void recursively_free_nodes(bst_node *node) {
+	if(node) {
+		recursively_free_nodes(node->left);
+		recursively_free_nodes(node->right);
+		xfree(node);
+	}
+}
+
+static void bst_free(bst *tree) {
+	if (tree) {
+		recursively_free_nodes(tree->root);
+	}
+}
+
+static bst* create_bst(int (*compare_function)(VALUE, VALUE)) {
+	bst *tree = ALLOC(bst);
+	tree->compare_function = compare_function;
+	tree->root = NULL;
+	tree->size = 0;
+	return tree;
+}
+
+static VALUE bst_alloc(VALUE klass) {
+	bst *tree = create_bst(&bst_compare_function);
+	return Data_Wrap_Struct(klass, bst_mark, bst_free, tree);
+}
+
+static VALUE rb_bst_push_value(VALUE self, VALUE key, VALUE value) {
+	bst *tree = get_bst_from_self(self);
+	insert_element(tree, &(tree->root), create_node(key,value));
+	tree->size++;
+	return self;
+}
+
+static void bst_each_helper(bst *tree, bst_node *node, void *args) {
+	rb_yield(rb_ary_new3(2, node->key, node->value));
+};
+
+static VALUE rb_bst_each(VALUE self) {
+	bst *tree = get_bst_from_self(self);
+	bst_each(tree, &bst_each_helper, NULL);
+	return self;
+}
+
+static VALUE rb_bst_delete(VALUE self, VALUE key) {
+	bst *tree = get_bst_from_self(self);
+	bst_node *tobeDeleted = search_node(tree, tree->root, key);
+	if(tobeDeleted) { 
+		tree->size -= 1;
+		bst_node *deletedNode = delete_node(&(tree->root),tobeDeleted);
+		return deletedNode->value;
+	}
+	return Qnil;
+}
+
+static VALUE rb_bst_size(VALUE self) { 
+	bst *tree;
+	Data_Get_Struct(self,bst,tree);
+	return INT2FIX(tree->size);
+}
+
+static VALUE CBst;
+static VALUE mContainers;
+
+void Init_CBst() {
+	id_compare_operator = rb_intern("<=>");
+
+	mContainers = rb_define_module("Containers");
+	CBst = rb_define_class_under(mContainers, "CBst", rb_cObject);
+	rb_define_alloc_func(CBst, bst_alloc);
+	rb_define_method(CBst, "initialize", bst_initialize, 0);
+	rb_define_method(CBst, "push", rb_bst_push_value, 2);
+	rb_define_alias(CBst, "[]=", "push");
+	rb_define_method(CBst, "each", rb_bst_each, 0);
+	rb_define_method(CBst, "delete", rb_bst_delete, 1);
+	rb_define_method(CBst, "size", rb_bst_size, 0);
+}

data/ext/containers/bst/extconf.rb

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

data/ext/containers/deque/deque.c

@@ -0,0 +1,247 @@
+#include "ruby.h"
+
+#define FALSE 0
+#define TRUE 1
+
+typedef struct struct_deque_node {
+	VALUE obj;
+	struct struct_deque_node *left;
+	struct struct_deque_node *right;
+} deque_node;
+
+typedef struct {
+	unsigned int size;
+	deque_node *front;
+	deque_node *back;
+} deque;
+
+void free_nodes(deque_node *node) {
+	deque_node *next;
+	while(node) {
+		next = node->right;
+		xfree(node);
+		node = next;
+	}
+	return;
+}
+
+void clear_deque(deque *a_deque) {
+	if(a_deque->front)
+		free_nodes(a_deque->front);
+	a_deque->size = 0;
+	a_deque->front = NULL;
+	a_deque->back = NULL;
+	return;
+}
+
+static deque* get_deque_from_self(VALUE self) {
+	deque *a_deque;
+	Data_Get_Struct(self, deque, a_deque);
+	return a_deque;
+}
+
+static deque* create_deque() {
+	deque *a_deque = ALLOC(deque);
+	a_deque->size = 0;
+	a_deque->front = NULL;
+	a_deque->back = NULL;
+	return a_deque;
+}
+
+static deque_node* create_node(VALUE obj) {
+	deque_node *node = ALLOC(deque_node);
+	node->obj = obj;
+	node->left = NULL;
+	node->right = NULL;
+	return node;
+}
+
+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);
+		xfree(deque);
+	}
+}
+
+static VALUE deque_alloc(VALUE klass) {
+	deque *deque = create_deque();
+	return Data_Wrap_Struct(klass, deque_mark, deque_free, deque);
+}
+
+static VALUE deque_push_front(VALUE self, VALUE obj) {
+	deque *deque = get_deque_from_self(self);
+	deque_node *node = create_node(obj);
+	if(deque->front) {
+		node->right = deque->front;
+		deque->front->left = node;
+		deque->front = node; 
+	}
+	else {
+		deque->front = node;
+		deque->back = node;
+	}
+	deque->size++;
+	return obj;
+}
+
+static VALUE deque_push_back(VALUE self, VALUE obj) {
+	deque *deque = get_deque_from_self(self);
+	deque_node *node = create_node(obj);
+	if(deque->back) {
+		node->left = deque->back;
+		deque->back->right = node;
+		deque->back = node; 
+	}
+	else {
+		deque->front = node;
+		deque->back = node;
+	}
+	deque->size++;
+	return obj;
+}
+
+static VALUE deque_pop_front(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	VALUE obj;
+	if(!deque->front)
+		return Qnil;
+	deque_node *node = deque->front;
+	obj = node->obj;
+	if(deque->size == 1) {
+		clear_deque(deque);
+		return obj;
+	}
+	deque->front->right->left = NULL;
+	deque->front = deque->front->right;
+	deque->size--;
+	return obj;
+}
+
+static VALUE deque_front(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	if(deque->front)
+		return deque->front->obj;
+	
+	return Qnil;
+}
+
+static VALUE deque_back(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	if(deque->back)
+		return deque->back->obj;
+	
+	return Qnil;
+}
+
+static VALUE deque_pop_back(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	VALUE obj;
+	if(!deque->back)
+		return Qnil;
+	deque_node *node = deque->back;
+	obj = node->obj;
+	if(deque->size == 1) {
+		clear_deque(deque);
+		return obj;
+	}
+	deque->back->left->right = NULL;
+	deque->back = deque->back->left;
+	deque->size--;
+	return obj;
+}
+
+static VALUE deque_clear(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	clear_deque(deque);
+	return Qnil;
+}
+
+static VALUE deque_size(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	return INT2NUM(deque->size);
+}
+
+static VALUE deque_is_empty(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	return (deque->size == 0) ? Qtrue : Qfalse;
+}
+
+static VALUE deque_each_forward(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	deque_node *node = deque->front;
+	while(node) {
+		rb_yield(node->obj);
+		node = node->right;
+	}
+	return self;
+}
+
+static VALUE deque_each_backward(VALUE self) {
+	deque *deque = get_deque_from_self(self);
+	deque_node *node = deque->back;
+	while(node) {
+		rb_yield(node->obj);
+		node = node->left;
+	}
+	return self;
+}
+
+static VALUE deque_init(int argc, VALUE *argv, VALUE self)
+{
+	long len, i;
+	VALUE ary;
+	
+	if(argc == 0) {
+		return self;
+	}
+	else if(argc > 1) {
+		rb_raise(rb_eArgError, "wrong number of arguments");
+	}
+	else {
+		ary = rb_check_array_type(argv[0]);
+		if(!NIL_P(ary)) {
+			len = RARRAY_LEN(ary);
+			for (i = 0; i < len; i++) {
+				deque_push_back(self, RARRAY_PTR(ary)[i]);
+			}
+		}
+	}
+	return self;
+}
+
+static VALUE cDeque;
+static VALUE mContainers;
+
+void Init_CDeque() {
+	mContainers = rb_define_module("Containers");
+	cDeque = rb_define_class_under(mContainers, "CDeque", rb_cObject);
+	rb_define_alloc_func(cDeque, deque_alloc);
+	rb_define_method(cDeque, "initialize", deque_init, -1);
+	rb_define_method(cDeque, "push_front", deque_push_front, 1);
+	rb_define_method(cDeque, "push_back", deque_push_back, 1);
+	rb_define_method(cDeque, "clear", deque_clear, 0);
+	rb_define_method(cDeque, "front", deque_front, 0);
+	rb_define_method(cDeque, "back", deque_back, 0);
+	rb_define_method(cDeque, "pop_front", deque_pop_front, 0);
+	rb_define_method(cDeque, "pop_back", deque_pop_back, 0);
+	rb_define_method(cDeque, "size", deque_size, 0);
+	rb_define_alias(cDeque, "length", "size");
+	rb_define_method(cDeque, "empty?", deque_is_empty, 0);
+	rb_define_method(cDeque, "each_forward", deque_each_forward, 0);
+	rb_define_method(cDeque, "each_backward", deque_each_backward, 0);
+	rb_define_alias(cDeque, "each", "each_forward");
+	rb_define_alias(cDeque, "reverse_each", "each_backward");
+	rb_include_module(cDeque, rb_eval_string("Enumerable"));
+}