bktree 0.0.1

data/README

@@ -0,0 +1,28 @@
+BkTrees are pretty cool.
+
+
+This one is extremely alpha though, so... You should probably look elsewhere.  It's pretty fast though, and that's pretty cool.
+
+
+Anyway, if you want to give it a shot just do something like this:
+
+  ruby extconf.rb && make
+
+
+And using it is really simple.  It only has two methods:
+
+  require 'bktree'
+
+  bk = BkTree.new
+  bk.add 'foo'
+  bk.add 'bar'
+  bk.add 'baz'
+
+  bk.query 'bor', 2  #=> [['bar', 1], ['baz', 2]]
+
+
+Have fun.
+
+
+           Your pal,
+             Tyler McMullen

data/bktree.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name = 'bktree'
+  s.version = '0.0.1'
+  s.authors = ["Tyler McMullen"]
+  s.date = '2010-02-13'
+  s.description = 'bktree in c with ruby bindings'
+  s.email = 'tbmcmullen@gmail.com'
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = ["README"]
+  s.files = Dir['*'] + Dir['ext/*.{c,h,rb}']
+  s.homepage = 'http://github.com/tyler/BkTree'
+  s.require_paths = ["ext"]
+  s.rubygems_version = '1.3.5'
+  s.summary = 'bktree in c with ruby bindings'
+end

data/ext/bktree.c

@@ -0,0 +1,50 @@
+#include "ruby.h"
+#include "bktree.h"
+#include "levenshtein.h"
+
+VALUE cBkTree;
+
+static VALUE rb_bktree_alloc(VALUE klass) {
+    VALUE obj;
+    obj = Data_Wrap_Struct(klass, 0, bktree_destroy, bktree_new(levenshtein_distance));
+    return obj;
+}
+
+static VALUE rb_bktree_add(VALUE self, VALUE word) {
+    StringValue(word);
+
+    BKTree * bktree;
+    Data_Get_Struct(self, BKTree, bktree);
+
+    bktree_add(bktree, RSTRING(word)->ptr, RSTRING(word)->len);
+
+    return Qnil;
+}
+
+static VALUE rb_bktree_query(VALUE self, VALUE word, VALUE max) {
+    StringValue(word);
+
+    BKTree * bktree;
+    Data_Get_Struct(self, BKTree, bktree);
+
+    VALUE result_out = rb_ary_new();
+    BKResult * result = bktree_query(bktree, RSTRING(word)->ptr, RSTRING(word)->len, FIX2INT(max));
+    while(result) {
+        VALUE result_node = rb_ary_new();
+
+        rb_ary_push(result_node, rb_str_new(BKTREE_GET_STRING(bktree, result->string_offset), BKTREE_GET_STRING_LEN(bktree, result->string_offset)));
+        rb_ary_push(result_node, INT2FIX(result->distance));
+
+        rb_ary_push(result_out, result_node);
+        result = result->next;
+    }
+
+    return result_out;
+}
+
+void Init_bktree() {
+    cBkTree = rb_define_class("BkTree", rb_cObject);
+    rb_define_alloc_func(cBkTree, rb_bktree_alloc);
+    rb_define_method(cBkTree, "add", rb_bktree_add, 1);
+    rb_define_method(cBkTree, "query", rb_bktree_query, 2);
+}

data/ext/bktree.h

@@ -0,0 +1,47 @@
+#define BKTREE_STRINGS_SIZE 4096
+#define BKTREE_TREE_SIZE 2147483648
+
+#define BKTREE_STRING_MAX 16
+
+#define BKTREE_OK 0
+#define BKTREE_FAIL 1
+
+#define BKTREE_GET_STRING(bktree, string_offset) (bktree->strings + string_offset + 1)
+
+#define BKTREE_GET_STRING_LEN(bktree, string_offset) (*(bktree->strings + string_offset))
+
+typedef struct {
+    long string_offset;
+    int next[BKTREE_STRING_MAX];
+} BKNode;
+
+typedef struct {
+    int size;
+
+    BKNode * tree;
+    BKNode * tree_cursor;
+    size_t tree_size;
+
+    char * strings;
+    char * strings_cursor;
+    size_t strings_size;
+
+    // word1, len(word1), word2, len(word2), max
+    int (* distance)(char *, int, char *, int, int);
+} BKTree;
+
+struct BKResult_s {
+    int distance;
+    int string_offset;
+    struct BKResult_s * next;
+};
+typedef struct BKResult_s BKResult;
+
+
+BKTree * bktree_new(int (* distance)(char *, int, char *, int, int));
+void bktree_destroy(BKTree * bktree);
+BKNode * bktree_add(BKTree * bktree, char * string, unsigned char len);
+void bktree_node_print(BKTree * bktree, BKNode * node);
+
+void bktree_result_destroy(BKResult * result);
+BKResult * bktree_query(BKTree * bktree, char * string, unsigned char len, int max);

data/ext/bktree_c.c

@@ -0,0 +1,156 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "bktree.h"
+
+static int write_string(BKTree * bktree, char * string, unsigned char len);
+static BKNode * write_new_record(BKTree * bktree, char * string, unsigned char len);
+
+BKTree * bktree_new(int (* distance)(char *, int, char *, int, int)) {
+    BKTree * bktree = malloc(sizeof(BKTree));
+
+    bktree->tree_size = BKTREE_TREE_SIZE;
+    bktree->tree = malloc(bktree->tree_size);
+    bktree->tree_cursor = bktree->tree;
+    
+    bktree->strings_size = BKTREE_STRINGS_SIZE;
+    bktree->strings = malloc(bktree->strings_size);
+    bktree->strings_cursor = bktree->strings;
+
+    bktree->size = 0;
+
+    bktree->distance = distance;
+
+    return bktree;
+}
+
+void bktree_destroy(BKTree * bktree) {
+    free(bktree->tree);
+    free(bktree->strings);
+    free(bktree);
+}
+
+BKNode * bktree_add(BKTree * bktree, char * string, unsigned char len) {
+    if(len > BKTREE_STRING_MAX || len == 0)
+        return NULL;
+
+    if(bktree->size == 0) {
+        return write_new_record(bktree, string, len);
+    }
+
+    BKNode * node = (BKNode *) bktree->tree;
+    while(node) {
+        char * node_str = BKTREE_GET_STRING(bktree, node->string_offset);
+        int node_str_len = BKTREE_GET_STRING_LEN(bktree, node->string_offset);
+
+        int d = bktree->distance(node_str, node_str_len, string, len, -1);
+
+        if(d == 0)
+            return BKTREE_OK;
+
+        if(node->next[d] > 0) {
+            node = bktree->tree + node->next[d];
+        } else {
+            BKNode * new_node = write_new_record(bktree, string, len);
+            node->next[d] = new_node - bktree->tree;
+            return new_node;
+        }
+    }
+
+    return NULL;
+}
+
+BKResult * bktree_result_new(BKResult * next, BKNode * node, int distance) {
+    BKResult * result = malloc(sizeof(BKResult));
+    result->next = next;
+    result->distance = distance;
+    result->string_offset = node->string_offset;
+
+    return result;
+}
+
+void inner_query(BKTree * bktree, BKNode * node, char * string, unsigned char len, int max, BKResult * * result_ptr) {
+
+    int d = bktree->distance(BKTREE_GET_STRING(bktree, node->string_offset), BKTREE_GET_STRING_LEN(bktree, node->string_offset), string, len, -1);
+
+    int start = d - max < 1 ? 1 : d - max;
+    int stop = d + max + 1;
+    if(stop >= BKTREE_STRING_MAX)
+        stop = BKTREE_STRING_MAX - 1;
+
+    if(d <= max) {
+        *result_ptr = bktree_result_new(*result_ptr, node, d);
+    }
+
+    int i;
+    for(i = start; i <= stop; i++) {
+        if(node->next[i] > 0) {
+            inner_query(bktree, bktree->tree + node->next[i], string, len, max, result_ptr);
+        }
+    }
+}
+
+BKResult * bktree_query(BKTree * bktree, char * string, unsigned char len, int max) {
+    BKResult * results = NULL;
+    inner_query(bktree, bktree->tree, string, len, max, &results);
+    return results;
+}
+
+void bktree_node_print(BKTree * bktree, BKNode * node) {
+    if(bktree == NULL) {
+        printf("bktree is null\n");
+        return;
+    }
+
+    if(node == NULL) {
+        printf("node is null\n");
+        return;
+    }
+
+    printf("String: %s\n", BKTREE_GET_STRING(bktree, node->string_offset));
+    printf("Offset: %ld\n", node - bktree->tree);
+    int i;
+    for(i = 0; i < BKTREE_STRING_MAX; i++)
+        printf("%d ", node->next[i]);
+
+    printf("\n");
+}
+
+static int write_string(BKTree * bktree, char * string, unsigned char len) {
+    while(bktree->strings_cursor - bktree->strings + len + 2 >= bktree->strings_size) {
+        int cursor_offset = bktree->strings_cursor - bktree->strings;
+
+        char * old_strings = bktree->strings;
+        bktree->strings = malloc(bktree->strings_size * 2);
+        memcpy(bktree->strings, old_strings, bktree->strings_size);
+        free(old_strings);
+
+        //printf("old ptr: %p\n", old_strings);
+        //printf("new ptr: %p\n", bktree->strings);
+
+        bktree->strings_size *= 2;
+        bktree->strings_cursor = bktree->strings + cursor_offset;
+    }
+
+    int original_offset = bktree->strings_cursor - bktree->strings;
+
+    *(bktree->strings_cursor) = len;
+    memcpy(bktree->strings_cursor + 1, string, len);
+    *(bktree->strings_cursor + len + 1) = '\0';
+    bktree->strings_cursor += len + 2;
+
+    return original_offset;
+}
+
+static BKNode * write_new_record(BKTree * bktree, char * string, unsigned char len) {
+    BKNode * node = bktree->tree_cursor++;
+    node->string_offset = write_string(bktree, string, len);
+    
+    int i;
+    for(i = 0; i < BKTREE_STRING_MAX; i++)
+        node->next[i] = 0;
+    
+    bktree->size++;
+    
+    return node;
+}

data/ext/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile 'bktree'

data/ext/levenshtein.c

@@ -0,0 +1,155 @@
+#include <stdlib.h>
+#include <string.h>
+#include "levenshtein.h"
+
+static int minimum(int a,int b,int c)
+/*Gets the minimum of three values*/
+{
+  int min=a;
+  if(b<min)
+    min=b;
+  if(c<min)
+    min=c;
+  return min;
+}
+
+int levenshtein_distance(char *s, int n, char*t, int m, int noop)
+/*Compute levenshtein distance between s and t*/
+{
+  //Step 1
+  int k,i,j,cost,*d,distance;
+  if(n!=0&&m!=0)
+  {
+    d=malloc((sizeof(int))*(m+1)*(n+1));
+    m++;
+    n++;
+    //Step 2	
+    for(k=0;k<n;k++)
+	d[k]=k;
+    for(k=0;k<m;k++)
+      d[k*n]=k;
+    //Step 3 and 4	
+    for(i=1;i<n;i++)
+      for(j=1;j<m;j++)
+	{
+        //Step 5
+        if(s[i-1]==t[j-1])
+          cost=0;
+        else
+          cost=1;
+        //Step 6			 
+        d[j*n+i]=minimum(d[(j-1)*n+i]+1,d[j*n+i-1]+1,d[(j-1)*n+i-1]+cost);
+      }
+    distance=d[n*m-1];
+    free(d);
+    return distance;
+  }
+  else 
+    return -1; //a negative return value means that one or both strings are empty.
+}
+
+int levenshtein(char * s1, int l1, char * s2, int l2, int threshold) {
+  int * prev_row, * curr_row;
+  int col, row;
+  int curr_row_min, result;
+  int offset = 0;
+
+  /* Do the expensive calculation on a subset of the sequences, if possible, by removing the common prefix. */
+
+  while (s1[offset] == s2[offset]) {
+    offset++;
+  }
+
+  /* Do the expensive calculation on a subset of the sequences, if possible, by removing the common postfix. */
+
+  while ((l1-1 > offset) && (l2-1 > offset) && (s1[l1-1] == s2[l2-1])) {
+    l1--;
+    l2--;
+  }
+
+  l1 -= offset;
+  l2 -= offset;
+
+  /* The Levenshtein algorithm itself. */
+
+  /*       s1=              */
+  /*       ERIK             */
+  /*                        */
+  /*      01234             */
+  /* s2=V 11234             */
+  /*    E 21234             */
+  /*    E 32234             */
+  /*    N 43334 <- prev_row */
+  /*    S 54444 <- curr_row */
+  /*    T 65555             */
+  /*    R 76566             */
+  /*    A 87667             */
+
+  /* Allocate memory for both rows */
+
+  prev_row	= malloc(l1+1);
+  curr_row	= malloc(l1+1);
+
+  if ((prev_row == NULL) || (curr_row == NULL)) {
+      return -1;
+  }
+
+  /* Initialize the current row. */
+
+  for (col=0; col<=l1; col++) {
+    curr_row[col] = col;
+  }
+
+  for (row=1; row<=l2; row++) {
+    /* Copy the current row to the previous row. */
+
+    memcpy(prev_row, curr_row, sizeof(int)*(l1+1));
+
+    /* Calculate the values of the current row. */
+
+    curr_row[0]		= row;
+    curr_row_min	= row;
+
+    for (col=1; col<=l1; col++) {
+      /* Equal (cost=0) or substitution (cost=1). */
+
+      curr_row[col]	= prev_row[col-1] + ((s1[offset+col-1] == s2[offset+row-1]) ? 0 : 1);
+
+      /* Insertion if it's cheaper than substitution. */
+
+      if (prev_row[col]+1 < curr_row[col]) {
+        curr_row[col] = prev_row[col]+1;
+      }
+
+      /* Deletion if it's cheaper than substitution. */
+
+      if (curr_row[col-1]+1 < curr_row[col]) {
+        curr_row[col] = curr_row[col-1]+1;
+      }
+
+      /* Keep track of the minimum value on this row. */
+
+      if (curr_row[col] < curr_row_min) {
+        curr_row_min	= curr_row[col];
+      }
+    }
+
+    /* Return nil as soon as we exceed the threshold. */
+
+    if (threshold > -1 && curr_row_min >= threshold) {
+      free(prev_row);
+      free(curr_row);
+
+      return -1;
+    }
+  }
+
+  /* The result is the last value on the last row. */
+
+  result = curr_row[l1];
+
+  free(prev_row);
+  free(curr_row);
+
+  return result;
+}

data/ext/levenshtein.h

@@ -0,0 +1,3 @@
+int levenshtein(char * s1, int l1, char * s2, int l2, int threshold);
+int levenshtein_distance(char *s, int n, char*t, int m, int noop);
+

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: bktree
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Tyler McMullen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-13 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: bktree in c with ruby bindings
+email: tbmcmullen@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README
+files: 
+- bktree.gemspec
+- README
+- ext/bktree.c
+- ext/bktree_c.c
+- ext/levenshtein.c
+- ext/bktree.h
+- ext/levenshtein.h
+- ext/extconf.rb
+has_rdoc: true
+homepage: http://github.com/tyler/BkTree
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: bktree in c with ruby bindings
+test_files: []
+