algorithms 0.3.0-jruby

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;
+		free(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);
+		free(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)
+{
+	int 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"));
+}

data/ext/containers/deque/extconf.rb

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

data/ext/containers/rbtree_map/extconf.rb

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

data/ext/containers/rbtree_map/rbtree.c

@@ -0,0 +1,498 @@
+#include "ruby.h"
+
+#define RED 1
+#define BLACK 0
+
+#define FALSE 0
+#define TRUE 1
+
+typedef struct struct_rbtree_node {
+	int color;
+	VALUE key;
+	VALUE value;
+	struct struct_rbtree_node *left;
+	struct struct_rbtree_node *right;
+	unsigned int height;
+	unsigned int num_nodes;
+} rbtree_node;
+
+typedef struct {
+	unsigned int black_height;
+	int (*compare_function)(VALUE key1, VALUE key2);
+	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);
+		recursively_free_nodes(node->right);
+		free(node);
+	}
+	return;
+}
+
+static rbtree* get_tree_from_self(VALUE self) {
+	rbtree *tree;
+	Data_Get_Struct(self, rbtree, tree);
+	return tree;
+}
+
+static int isred(rbtree_node *node) {
+	if(!node) { return FALSE; }
+	
+	if(node->color == RED) { return TRUE; }
+	else return FALSE;
+}
+
+static void colorflip(rbtree_node *node) {
+	node->color = !node->color;
+	node->left->color = !node->left->color;
+	node->right->color = !node->right->color;
+}
+
+static int size(rbtree_node *h) {
+	if(!h) {
+		return 0;
+	}
+	else return h->num_nodes;
+}
+
+static int height(rbtree_node *h) {
+	if(!h) { return 0; }
+	else return h->height;
+}
+
+static rbtree_node* set_num_nodes(rbtree_node *h) {
+	h->num_nodes = size(h->left) + size(h->right) + 1;
+	if ( height(h->left) > height(h->right) ) {
+		h->height = height(h->left) +1;
+	}
+	else {
+		h->height = height(h->right) +1;
+	}
+	return h;
+}
+
+static rbtree_node* rotate_left(rbtree_node *h) {
+	rbtree_node *x = h->right;
+	h->right = x->left;
+	x->left = set_num_nodes(h);
+	x->color = x->left->color;
+	x->left->color = RED;
+	return set_num_nodes(x);	
+}
+
+static rbtree_node* rotate_right(rbtree_node *h) {
+	rbtree_node *x = h->left;
+	h->left = x->right;
+	x->right = set_num_nodes(h);
+	x->color = x->right->color;
+	x->right->color = RED;
+	return set_num_nodes(x);	
+}
+
+static rbtree_node* move_red_left(rbtree_node *h) {
+	colorflip(h);
+	if ( isred(h->right->left) ) {
+		h->right = rotate_right(h->right);
+		h = rotate_left(h);
+		colorflip(h);
+	}
+	return h;
+}
+
+static rbtree_node* move_red_right(rbtree_node *h) {
+	colorflip(h);
+	if ( isred(h->left->left) ) {
+		h = rotate_right(h);
+		colorflip(h);
+	}
+	return h;
+}
+
+static rbtree_node* fixup(rbtree_node *h) {
+	if ( isred(h->right) )
+		h = rotate_left(h);
+	
+	if ( isred(h->left) && isred(h->left->left) )
+		h = rotate_right(h);
+	
+	if ( isred(h->left) && isred(h->right) )
+		colorflip(h);
+		
+	return set_num_nodes(h);
+}
+
+static rbtree* create_rbtree(int (*compare_function)(VALUE, VALUE)) {
+	rbtree *tree = ALLOC(rbtree);
+	tree->black_height = 0;
+	tree->compare_function = compare_function;
+	tree->root = NULL;
+	return tree;
+}
+
+static rbtree_node* insert(rbtree *tree, rbtree_node *node, VALUE key, VALUE value) {
+	int cmp;
+	
+	// This slot is empty, so we insert our new node
+	if(!node) {
+		rbtree_node *new_node = ALLOC(rbtree_node);
+		new_node->key		= key;
+		new_node->value		= value;
+		new_node->color		= RED;
+		new_node->height	= 1;
+		new_node->num_nodes = 1;
+		new_node->left		= NULL;
+		new_node->right		= NULL;
+		return new_node;
+	}
+	
+	// Insert left or right, recursively
+	cmp = tree->compare_function(key, node->key);
+	if		(cmp == 0)	{ node->value = value; }
+	else if (cmp == -1) { node->left	= insert(tree, node->left, key, value); }
+	else				{ node->right = insert(tree, node->right, key, value); }
+	
+	// Fix our tree to keep left-lean
+	if (isred(node->right)) { node = rotate_left(node); }
+	if (isred(node->left) && isred(node->left->left)) { node = rotate_right(node); }
+	if ( isred(node->left) && isred(node->right) ) {
+		colorflip(node);
+	}
+	return set_num_nodes(node);
+}
+
+static VALUE get(rbtree *tree, rbtree_node *node, VALUE key) {
+	int cmp;
+	if (!node) {
+		return Qnil;
+	}
+	
+	cmp = tree->compare_function(key, node->key);
+	if		(cmp == 0)	{ return node->value; }
+	else if (cmp == -1) { return get(tree, node->left, key); }
+	else				{ return get(tree, node->right, key); }
+	
+}
+
+static VALUE min_key(rbtree_node *node) {
+	while (node->left)
+		node = node->left;
+		
+	return node->key;
+}
+
+static VALUE max_key(rbtree_node *node) {
+	while (node->right)
+		node = node->right;
+	
+	return node->key;
+}
+
+static rbtree_node* delete_min(rbtree_node *h, VALUE *deleted_value) {
+	if ( !h->left ) {
+		if(deleted_value)
+			*deleted_value = h->value;
+		free(h);
+		return NULL;
+	}
+	
+	if ( !isred(h->left) && !isred(h->left->left) )
+		h = move_red_left(h);
+
+	h->left = delete_min(h->left, deleted_value);
+
+	return fixup(h);
+}
+
+static rbtree_node* delete_max(rbtree_node *h, VALUE *deleted_value) {
+	if ( isred(h->left) )
+		h = rotate_right(h);
+
+	if ( !h->right ) {
+		*deleted_value = h->value;
+		free(h);
+		return NULL;
+	}
+
+	if ( !isred(h->right) && !isred(h->right->left) )
+		h = move_red_right(h);
+
+	h->right = delete_max(h->right, deleted_value);
+
+	return fixup(h);
+}
+
+static rbtree_node* delete(rbtree *tree, rbtree_node *node, VALUE key, VALUE *deleted_value) {
+	int cmp;
+	VALUE minimum_key;
+	cmp = tree->compare_function(key, node->key);
+	if (cmp == -1) {
+		if ( !isred(node->left) && !isred(node->left->left) )
+			node = move_red_left(node);
+		
+		node->left = delete(tree, node->left, key, deleted_value);
+	}
+	else {
+		if ( isred(node->left) )
+			node = rotate_right(node);
+		
+		cmp = tree->compare_function(key, node->key);
+		if ( (cmp == 0) && !node->right ) {
+			*deleted_value = node->value;
+			free(node);
+			return NULL;
+		}
+
+		if ( !isred(node->right) && !isred(node->right->left) )
+			node = move_red_right(node);
+		
+		cmp = tree->compare_function(key, node->key);
+		if (cmp == 0) {
+			*deleted_value = node->value;
+			minimum_key = min_key(node->right);
+			node->value = get(tree, node->right, minimum_key);
+			node->key = minimum_key;
+			node->right = delete_min(node->right, NULL);
+		}
+		else {
+			node->right = delete(tree, node->right, key, deleted_value);
+		}
+	}
+	return fixup(node);
+}
+
+static rbtree* rbtree_each_node(rbtree *tree, rbtree_node *node, void (*each)(rbtree *tree_, rbtree_node *node_, void* args), void* arguments) {
+	if (!node)
+		return NULL;
+	
+		if (node->left)
+			rbtree_each_node(tree, node->left, each, arguments);
+	(*each)(tree, node, arguments);
+		if (node->right)
+			rbtree_each_node(tree, node->right, each, arguments);
+	return tree;
+}
+
+static rbtree* rbt_each(rbtree *tree, void (*each)(rbtree *tree, rbtree_node *node, void *args), void* arguments) {
+	if (tree->root)
+			rbtree_each_node(tree, tree->root, each, arguments);
+		return tree;
+}
+
+// Methods to be called in Ruby
+
+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 && 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 VALUE rbtree_init(VALUE self)
+{
+	return self;
+}
+
+static void rbtree_mark(void *ptr) {
+	ll_node *current, *new, *last, *old;
+	if (ptr) {
+		rbtree *tree = ptr;
+		
+		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);
+			}
+		}
+	}
+}
+
+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, rbtree_mark, rbtree_free, tree);
+}
+
+static VALUE rbtree_push(VALUE self, VALUE key, VALUE value) {
+	rbtree *tree = get_tree_from_self(self);
+	tree->root = insert(tree, tree->root, key, value);
+	return value;
+}
+
+static VALUE rbtree_get(VALUE self, VALUE key) {
+	rbtree *tree = get_tree_from_self(self);
+	return get(tree, tree->root, key);
+}
+
+static VALUE rbtree_size(VALUE self) {
+	rbtree *tree = get_tree_from_self(self);
+	return INT2NUM(size(tree->root));
+}
+
+static VALUE rbtree_is_empty(VALUE self) {
+	rbtree *tree = get_tree_from_self(self);
+	return (tree->root ? Qfalse : Qtrue);
+}
+
+static VALUE rbtree_height(VALUE self) {
+	rbtree *tree = get_tree_from_self(self);
+	return INT2NUM(height(tree->root));
+}
+
+static VALUE rbtree_has_key(VALUE self, VALUE key) {
+	rbtree *tree = get_tree_from_self(self);
+	if(!tree->root) { return Qfalse; }
+	if(get(tree, tree->root, key) == Qnil)
+		return Qfalse;
+	
+	return Qtrue;
+}
+
+static VALUE rbtree_min_key(VALUE self) {
+	rbtree *tree = get_tree_from_self(self);
+	if(!tree->root)
+		return Qnil;
+	
+	return min_key(tree->root);
+}
+
+static VALUE rbtree_max_key(VALUE self) {
+	rbtree *tree = get_tree_from_self(self);
+	if(!tree->root)
+		return Qnil;
+	
+	return max_key(tree->root);
+}
+
+static VALUE rbtree_delete(VALUE self, VALUE key) {
+	VALUE deleted_value;
+	rbtree *tree = get_tree_from_self(self);
+	if(!tree->root)
+		return Qnil;
+	
+	tree->root = delete(tree, tree->root, key, &deleted_value);
+	if(tree->root)
+		tree->root->color = BLACK;
+	
+	if(deleted_value) {
+		return deleted_value;
+	}
+		
+	return Qnil;
+}
+
+static VALUE rbtree_delete_min(VALUE self) {
+	VALUE deleted_value;
+	rbtree *tree = get_tree_from_self(self);
+	if(!tree->root)
+		return Qnil;
+	
+	tree->root = delete_min(tree->root, &deleted_value);
+	if(tree->root)
+		tree->root->color = BLACK;
+	
+	if(deleted_value) {
+		return deleted_value;
+	}
+		
+	return Qnil;
+}
+
+static VALUE rbtree_delete_max(VALUE self) {
+	VALUE deleted_value;
+	rbtree *tree = get_tree_from_self(self);
+	if(!tree->root)
+		return Qnil;
+	
+	tree->root = delete_max(tree->root, &deleted_value);
+	if(tree->root)
+		tree->root->color = BLACK;
+	
+	if(deleted_value) {
+		return deleted_value;
+	}
+		
+	return Qnil;
+}
+
+static void rbtree_each_helper(rbtree *tree, rbtree_node *node, void *args) {
+	rb_yield(rb_ary_new3(2, node->key, node->value));
+};
+
+static VALUE rbtree_each(VALUE self) {
+	rbtree *tree = get_tree_from_self(self);
+	rbt_each(tree, &rbtree_each_helper, NULL);
+	return self;
+}
+
+static VALUE cRBTree;
+static VALUE mContainers;
+
+void Init_CRBTreeMap() {
+	id_compare_operator = rb_intern("<=>");
+	
+	mContainers = rb_define_module("Containers");
+	cRBTree = rb_define_class_under(mContainers, "CRBTreeMap", rb_cObject);
+	rb_define_alloc_func(cRBTree, rbtree_alloc);
+	rb_define_method(cRBTree, "initialize", rbtree_init, 0);
+	rb_define_method(cRBTree, "push", rbtree_push, 2);
+	rb_define_alias(cRBTree, "[]=", "push");
+	rb_define_method(cRBTree, "size", rbtree_size, 0);
+	rb_define_method(cRBTree, "empty?", rbtree_is_empty, 0);
+	rb_define_method(cRBTree, "height", rbtree_height, 0);
+	rb_define_method(cRBTree, "min_key", rbtree_min_key, 0);
+	rb_define_method(cRBTree, "max_key", rbtree_max_key, 0);
+	rb_define_method(cRBTree, "delete_min", rbtree_delete_min, 0);
+	rb_define_method(cRBTree, "delete_max", rbtree_delete_max, 0);
+	rb_define_method(cRBTree, "each", rbtree_each, 0);
+	rb_define_method(cRBTree, "get", rbtree_get, 1);
+	rb_define_alias(cRBTree, "[]", "get");
+	rb_define_method(cRBTree, "has_key?", rbtree_has_key, 1);
+	rb_define_method(cRBTree, "delete", rbtree_delete, 1);
+	rb_include_module(cRBTree, rb_eval_string("Enumerable"));
+}