amatch 0.1.5 → 0.2.0

data/ext/extconf.rb

@@ -1,6 +1,11 @@
 #
-## $Id: extconf.rb,v 1.1.1.1 2004/09/27 19:23:42 flori Exp $
+## $Id: extconf.rb,v 1.2 2005/04/22 00:04:15 flori Exp $
 #
 
 require 'mkmf'
+require 'rbconfig'
+if CONFIG['CC'] = 'gcc'
+  CONFIG['CC'] = 'gcc -Wall '
+end
 create_makefile 'amatch' 
+  # vim: set et sw=2 ts=2:

data/ext/pair.c

@@ -0,0 +1,78 @@
+#include "pair.h"
+
+#define DEBUG 0
+
+static int predict_length(VALUE tokens)
+{
+    int i, l, result;
+    for (i = 0, result = 0; i < RARRAY(tokens)->len; i++) {
+        VALUE t = rb_ary_entry(tokens, i);
+        l = RSTRING(t)->len - 1;
+        if (l > 0) result += l;
+    }
+    return result;
+}
+
+PairArray *PairArray_new(VALUE tokens)
+{
+    int i, j, k, len = predict_length(tokens); 
+    PairArray *pair_array = ALLOC(PairArray);
+    Pair *pairs = ALLOC_N(Pair, len);
+    MEMZERO(pairs, Pair, len);
+    pair_array->pairs = pairs;
+    pair_array->len = len;
+    for (i = 0, k = 0; i < RARRAY(tokens)->len; i++) {
+        VALUE t = rb_ary_entry(tokens, i);
+        char *string = RSTRING(t)->ptr;
+        for (j = 0; j < RSTRING(t)->len - 1; j++) {
+            pairs[k].fst = string[j];
+            pairs[k].snd = string[j + 1];
+            pairs[k].status = PAIR_ACTIVE;
+            k++;
+        }
+    }
+    return pair_array;
+}
+
+void pair_array_reactivate(PairArray *self)
+{
+    int i;
+    for (i = 0; i < self->len; i++) { 
+        self->pairs[i].status = PAIR_ACTIVE;
+    }
+}
+
+double pair_array_match(PairArray *self, PairArray *other)
+{
+    int i, j, matches = 0;
+    int sum = self->len + other->len;
+    if (sum == 0) return 1.0;
+    for (i = 0; i < self->len; i++) {
+        for (j = 0; j < other->len; j++) {
+#if DEBUG
+            pair_print(self->pairs[i]);
+            putc(' ', stdout);
+            pair_print(other->pairs[j]);
+            printf(" -> %d\n", pair_equal(self->pairs[i], other->pairs[j]));
+#endif
+            if (pair_equal(self->pairs[i], other->pairs[j])) {
+                matches++;
+                other->pairs[j].status = PAIR_INACTIVE;
+                break;
+            }
+        }
+    }
+    return ((double) (2 * matches)) / sum;
+}
+
+void pair_print(Pair pair)
+{
+    printf("%c%c (%d)", pair.fst, pair.snd, pair.status);
+}
+
+void pair_array_destroy(PairArray *pair_array)
+{
+    free(pair_array->pairs);
+    free(pair_array);
+}
+  /* vim: set et cindent sw=4 ts=4: */ 

data/ext/pair.h

@@ -0,0 +1,29 @@
+#ifndef PAIR_H_INCLUDED
+#define PAIR_H_INCLUDED
+
+#include "ruby.h"
+
+enum { PAIR_ACTIVE = 1, PAIR_INACTIVE = 2 };
+
+typedef struct PairStruct {
+    char fst;
+    char snd;
+    char status;
+    char __align;
+} Pair;
+
+typedef struct PairArrayStruct {
+    Pair *pairs;
+    int len;
+} PairArray;
+
+PairArray *PairArray_new(VALUE tokens);
+#define pair_equal(a, b) \
+    ((a).fst == (b).fst && (a).snd == (b).snd && ((a).status & (b).status & PAIR_ACTIVE))
+double pair_array_match(PairArray *self, PairArray *other);
+void pair_array_destroy(PairArray *pair_array);
+void pair_print(Pair pair);
+void pair_array_reactivate(PairArray *self);
+
+#endif
+  /* vim: set et cindent sw=4 ts=4: */ 

data/ext/tags

@@ -0,0 +1,24 @@
+CAST2FLOAT	amatch.c	/^#define CAST2FLOAT(obj) \\$/
+DEF_ALLOCATOR	amatch.c	/^#define DEF_ALLOCATOR(type)                       /
+DEF_CONSTRUCTOR	amatch.c	/^#define DEF_CONSTRUCTOR(klass, type)              /
+DEF_ITERATE_STRINGS	amatch.c	/^#define DEF_ITERATE_STRINGS(type)                 /
+DEF_PATTERN_ACCESSOR	amatch.c	/^#define DEF_PATTERN_ACCESSOR(type)                /
+DEF_RB_FREE	amatch.c	/^#define DEF_RB_FREE(klass, type)                  /
+DEF_RB_READER	amatch.c	/^#define DEF_RB_READER(type, function, name, conver/
+DEF_RB_WRITER	amatch.c	/^#define DEF_RB_WRITER(type, function, name, vtype,/
+FLOAT2C	amatch.c	/^#define FLOAT2C(obj) RFLOAT(obj)->value$/
+GET_STRUCT	amatch.c	/^#define GET_STRUCT(klass)                 \\$/
+Init_amatch	amatch.c	/^void Init_amatch()$/
+Levenshtein_search	amatch.c	/^static VALUE Levenshtein_search(Levenshtein *amatc/
+PairDistance_match	amatch.c	/^static VALUE PairDistance_match($/
+amatch_LongestSubstring	amatch.c	/^static VALUE amatch_LongestSubstring(General *amat/
+hamming	amatch.c	/^static VALUE hamming(General *amatch, VALUE string/
+longest_subsequence	amatch.c	/^static VALUE longest_subsequence(General *amatch, /
+rb_Levenshtein_initialize	amatch.c	/^static VALUE rb_Levenshtein_initialize(VALUE self,/
+rb_Levenshtein_search	amatch.c	/^static VALUE rb_Levenshtein_search(VALUE self, VAL/
+rb_str_Levenshtein_match	amatch.c	/^static VALUE rb_str_Levenshtein_match(VALUE self, /
+rb_str_Levenshtein_search	amatch.c	/^static VALUE rb_str_Levenshtein_search(VALUE self,/
+rb_str_hamming	amatch.c	/^static VALUE rb_str_hamming(VALUE self, VALUE stri/
+rb_str_longest_subsequence	amatch.c	/^static VALUE rb_str_longest_subsequence(VALUE self/
+rb_str_longest_substring	amatch.c	/^static VALUE rb_str_longest_substring(VALUE self, /
+rb_str_pair_distance	amatch.c	/^static VALUE rb_str_pair_distance(VALUE self, VALU/

data/tests/runner.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'test/unit/ui/console/testrunner'
+require 'test/unit/testsuite'
+$:.unshift File.expand_path(File.dirname($0))
+require 'test_levenshtein'
+require 'test_sellers'
+require 'test_pair_distance'
+require 'test_hamming'
+require 'test_longest_subsequence'
+require 'test_longest_substring'
+
+class TS_AllTests
+  def self.suite
+    suite = Test::Unit::TestSuite.new 'All tests'
+    suite << TC_Levenshtein.suite
+    suite << TC_Sellers.suite
+    suite << TC_PairDistance.suite
+    suite << TC_Hamming.suite
+    suite << TC_LongestSubsequence.suite
+    suite << TC_LongestSubstring.suite
+    suite
+  end
+end
+Test::Unit::UI::Console::TestRunner.run(TS_AllTests)
+  # vim: set et sw=2 ts=2:

data/tests/test_hamming.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+require 'amatch'
+
+class TC_Hamming < Test::Unit::TestCase
+  include Amatch
+
+  D = 0.000001
+
+  def setup
+    @small   = Hamming.new('test')
+    @empty   = Hamming.new('')
+  end
+
+  def test_empty
+    assert_in_delta 0, @empty.match(''), D
+    assert_in_delta 9, @empty.match('not empty'), D
+    assert_in_delta 1, @empty.similar(''), D
+    assert_in_delta 0, @empty.similar('not empty'), D
+  end
+
+  def test_small_match
+    assert_in_delta 4, @small.match(''), D
+    assert_in_delta 0, @small.match('test'), D
+    assert_in_delta 1, @small.match('testa'), D
+    assert_in_delta 5, @small.match('atest'), D
+    assert_in_delta 3, @small.match('teast'), D
+    assert_in_delta 4, @small.match('est'), D
+    assert_in_delta 1, @small.match('tes'), D
+    assert_in_delta 3, @small.match('tst'), D
+    assert_in_delta 1, @small.match('best'), D
+    assert_in_delta 1, @small.match('tost'), D
+    assert_in_delta 1, @small.match('tesa'), D
+    assert_in_delta 3, @small.match('taex'), D
+    assert_in_delta 9, @small.match('aaatestbbb'), D
+  end
+
+  def test_small_similar
+    assert_in_delta 0.0, @small.similar(''), D
+    assert_in_delta 1.0, @small.similar('test'), D
+    assert_in_delta 0.8, @small.similar('testa'), D
+    assert_in_delta 0.0, @small.similar('atest'), D
+    assert_in_delta 0.4, @small.similar('teast'), D
+    assert_in_delta 0, @small.similar('est'), D
+    assert_in_delta 0.75, @small.similar('tes'), D
+    assert_in_delta 0.25, @small.similar('tst'), D
+    assert_in_delta 0.75, @small.similar('best'), D
+    assert_in_delta 0.75, @small.similar('tost'), D
+    assert_in_delta 0.75, @small.similar('tesa'), D
+    assert_in_delta 0.25, @small.similar('taex'), D
+    assert_in_delta 0.1, @small.similar('aaatestbbb'), D
+    assert_in_delta 0.8, @small.pattern.hamming_similar('testa'), D
+  end
+end
+  # vim: set et sw=2 ts=2:

data/tests/test_levenshtein.rb

@@ -0,0 +1,74 @@
+require 'test/unit'
+require 'amatch'
+
+class TC_Levenshtein < Test::Unit::TestCase
+  include Amatch
+
+  D = 0.000001
+  
+  def setup
+    @empty = Levenshtein.new('')
+    @simple = Levenshtein.new('test')
+  end
+
+  def test_match
+    assert_equal 4,     @simple.match('')
+    assert_equal 0,     @simple.match('test')
+    assert_equal 0,     @simple.match('test')
+    assert_equal 1,     @simple.match('testa')
+    assert_equal 1,     @simple.match('atest')
+    assert_equal 1,     @simple.match('teast')
+    assert_equal 1,     @simple.match('est')
+    assert_equal 1,     @simple.match('tes')
+    assert_equal 1,     @simple.match('tst')
+    assert_equal 1,     @simple.match('best')
+    assert_equal 1,     @simple.match('tost')
+    assert_equal 1,     @simple.match('tesa')
+    assert_equal 3,     @simple.match('taex')
+    assert_equal 6,     @simple.match('aaatestbbb')
+  end
+
+  def test_search
+    assert_equal 4,     @simple.search('')
+    assert_equal 0,     @empty.search('')
+    assert_equal 0,     @empty.search('test')
+    assert_equal 0,     @simple.search('aaatestbbb')
+    assert_equal 3,     @simple.search('aaataexbbb')
+    assert_equal 4,     @simple.search('aaaaaaaaa')
+  end
+
+  def test_array_result
+    assert_equal [2, 0],    @simple.match(["tets", "test"])
+    assert_equal [1, 0],    @simple.search(["tetsaaa", "testaaa"])
+    assert_raises(TypeError) { @simple.match([:foo, "bar"]) }
+  end
+
+  def test_pattern_setting
+    assert_raises(TypeError) { @simple.pattern = :something }
+    assert_equal 0, @simple.match('test')
+    @simple.pattern = ''
+    assert_equal 4, @simple.match('test')
+    @simple.pattern = 'test'
+    assert_equal 0, @simple.match('test')
+  end
+
+  def test_similar
+    assert_in_delta 1, @empty.similar(''), D
+    assert_in_delta 0, @empty.similar('not empty'), D
+    assert_in_delta 0.0, @simple.similar(''), D
+    assert_in_delta 1.0, @simple.similar('test'), D
+    assert_in_delta 0.8, @simple.similar('testa'), D
+    assert_in_delta 0.8, @simple.similar('atest'), D
+    assert_in_delta 0.8, @simple.similar('teast'), D
+    assert_in_delta 0.75, @simple.similar('est'), D
+    assert_in_delta 0.75, @simple.similar('tes'), D
+    assert_in_delta 0.75, @simple.similar('tst'), D
+    assert_in_delta 0.75, @simple.similar('best'), D
+    assert_in_delta 0.75, @simple.similar('tost'), D
+    assert_in_delta 0.75, @simple.similar('tesa'), D
+    assert_in_delta 0.25, @simple.similar('taex'), D
+    assert_in_delta 0.4, @simple.similar('aaatestbbb'), D
+    assert_in_delta 0.75, @simple.pattern.levenshtein_similar('est'), D
+  end
+end
+  # vim: set et sw=2 ts=2:

data/tests/test_longest_subsequence.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require 'amatch'
+
+class TC_LongestSubsequence < Test::Unit::TestCase
+  include Amatch
+
+  D = 0.000001
+
+  def setup
+    @small   = LongestSubsequence.new('test')
+    @empty   = LongestSubsequence.new('')
+  end
+
+  def test_empty_subsequence
+    assert_equal 0, @empty.match('')
+    assert_equal 0, @empty.match('a')
+    assert_equal 0, @small.match('')
+    assert_equal 0, @empty.match('not empty')
+  end
+
+  def test_small_subsequence
+    assert_equal 4, @small.match('test')
+    assert_equal 4, @small.match('testa')
+    assert_equal 4, @small.match('atest')
+    assert_equal 4, @small.match('teast')
+    assert_equal 3, @small.match('est')
+    assert_equal 3, @small.match('tes')
+    assert_equal 3, @small.match('tst')
+    assert_equal 3, @small.match('best')
+    assert_equal 3, @small.match('tost')
+    assert_equal 3, @small.match('tesa')
+    assert_equal 2, @small.match('taex')
+    assert_equal 1, @small.match('aaatbbb')
+    assert_equal 1, @small.match('aaasbbb')
+    assert_equal 4, @small.match('aaatestbbb')
+  end
+
+  def test_similar
+    assert_in_delta 1, @empty.similar(''), D
+    assert_in_delta 0, @empty.similar('not empty'), D
+    assert_in_delta 0.0, @small.similar(''), D
+    assert_in_delta 1.0, @small.similar('test'), D
+    assert_in_delta 0.8, @small.similar('testa'), D
+    assert_in_delta 0.8, @small.similar('atest'), D
+    assert_in_delta 0.8, @small.similar('teast'), D
+    assert_in_delta 0.75, @small.similar('est'), D
+    assert_in_delta 0.75, @small.similar('tes'), D
+    assert_in_delta 0.75, @small.similar('tst'), D
+    assert_in_delta 0.75, @small.similar('best'), D
+    assert_in_delta 0.75, @small.similar('tost'), D
+    assert_in_delta 0.75, @small.similar('tesa'), D
+    assert_in_delta 0.50, @small.similar('taex'), D
+    assert_in_delta 0.4, @small.similar('aaatestbbb'), D
+    assert_in_delta 0.75, @small.pattern.levenshtein_similar('est'), D
+  end
+end
+  # vim: set et sw=2 ts=2:

data/tests/test_longest_substring.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require 'amatch'
+
+class TC_LongestSubstring < Test::Unit::TestCase
+  include Amatch
+
+  D = 0.000001
+
+  def setup
+    @small   = LongestSubstring.new('test')
+    @empty   = LongestSubstring.new('')
+  end
+
+  def test_empty_substring
+    assert_in_delta 0, @empty.match(''), D
+    assert_in_delta 0, @empty.match('a'), D
+    assert_in_delta 0, @small.match(''), D
+    assert_in_delta 0, @empty.match('not empty'), D
+  end
+
+  def test_small_substring
+    assert_in_delta 4, @small.match('test'), D
+    assert_in_delta 4, @small.match('testa'), D
+    assert_in_delta 4, @small.match('atest'), D
+    assert_in_delta 2, @small.match('teast'), D
+    assert_in_delta 3, @small.match('est'), D
+    assert_in_delta 3, @small.match('tes'), D
+    assert_in_delta 2, @small.match('tst'), D
+    assert_in_delta 3, @small.match('best'), D
+    assert_in_delta 2, @small.match('tost'), D
+    assert_in_delta 3, @small.match('tesa'), D
+    assert_in_delta 1, @small.match('taex'), D
+    assert_in_delta 1, @small.match('aaatbbb'), D
+    assert_in_delta 1, @small.match('aaasbbb'), D
+    assert_in_delta 4, @small.match('aaatestbbb'), D
+  end
+
+  def test_similar
+    assert_in_delta 1, @empty.similar(''), D
+    assert_in_delta 0, @empty.similar('not empty'), D
+    assert_in_delta 0.0, @small.similar(''), D
+    assert_in_delta 1.0, @small.similar('test'), D
+    assert_in_delta 0.8, @small.similar('testa'), D
+    assert_in_delta 0.8, @small.similar('atest'), D
+    assert_in_delta 0.4, @small.similar('teast'), D
+    assert_in_delta 0.75, @small.similar('est'), D
+    assert_in_delta 0.75, @small.similar('tes'), D
+    assert_in_delta 0.5, @small.similar('tst'), D
+    assert_in_delta 0.75, @small.similar('best'), D
+    assert_in_delta 0.5, @small.similar('tost'), D
+    assert_in_delta 0.75, @small.similar('tesa'), D
+    assert_in_delta 0.25, @small.similar('taex'), D
+    assert_in_delta 0.4, @small.similar('aaatestbbb'), D
+    assert_in_delta 0.75, @small.pattern.levenshtein_similar('est'), D
+  end
+end
+  # vim: set et sw=2 ts=2:

data/tests/test_pair_distance.rb

@@ -0,0 +1,81 @@
+require 'test/unit'
+require 'amatch'
+
+class TC_PairDistance < Test::Unit::TestCase
+  include Amatch
+
+  D = 0.000001
+
+  def setup
+    @single   = PairDistance.new('test')
+    @empty    = PairDistance.new('')
+    @france   = PairDistance.new('republic of france')
+    @germany  = PairDistance.new('federal republic of germany')
+    @csv      = PairDistance.new('foo,bar,baz')
+  end
+
+  def test_empty
+    assert_in_delta 1, @empty.match(''), D
+    assert_in_delta 0, @empty.match('not empty'), D
+    assert_in_delta 1, @empty.similar(''), D
+    assert_in_delta 0, @empty.similar('not empty'), D
+  end
+
+  def test_countries
+    assert_in_delta 0.5555555,  @france.match('france'), D
+    assert_in_delta 0.1052631,  @france.match('germany'), D
+    assert_in_delta 0.4615384,  @germany.match('germany'), D
+    assert_in_delta 0.16,       @germany.match('france'), D
+    assert_in_delta 0.6829268,
+      @germany.match('german democratic republic'), D
+    assert_in_delta 0.72,
+      @france.match('french republic'), D
+    assert_in_delta 0.4375,
+      @germany.match('french republic'), D
+    assert_in_delta 0.5294117,
+      @france.match('german democratic republic'), D
+  end
+
+  def test_single
+    assert_in_delta 0,          @single.match(''), D
+    assert_in_delta 1,          @single.match('test'), D
+    assert_in_delta 0.8571428,  @single.match('testa'), D
+    assert_in_delta 0.8571428,  @single.match('atest'), D
+    assert_in_delta 0.5714285,  @single.match('teast'), D
+    assert_in_delta 0.8,        @single.match('est'), D
+    assert_in_delta 0.8,        @single.match('tes'), D
+    assert_in_delta 0.4,        @single.match('tst'), D
+    assert_in_delta 0.6666666,  @single.match('best'), D
+    assert_in_delta 0.3333333,  @single.match('tost'), D
+    assert_in_delta 0.6666666,  @single.match('tesa'), D
+    assert_in_delta 0.0,        @single.match('taex'), D
+    assert_in_delta 0.5,        @single.match('aaatestbbb'), D
+    assert_in_delta 0.6,        @single.match('aaa test bbb'), D
+    assert_in_delta 0.6,        @single.match('test aaa bbb'), D
+    assert_in_delta 0.6,        @single.match('bbb aaa test'), D
+  end
+
+  def test_csv
+    assert_in_delta 0,          @csv.match('', /,/), D
+    assert_in_delta 0.5,        @csv.match('foo', /,/), D
+    assert_in_delta 0.5,        @csv.match('bar', /,/), D
+    assert_in_delta 0.5,        @csv.match('baz', /,/), D
+    assert_in_delta 0.8,        @csv.match('foo,bar', /,/), D
+    assert_in_delta 0.8,        @csv.match('bar,foo', /,/), D
+    assert_in_delta 0.8,        @csv.match('bar,baz', /,/), D
+    assert_in_delta 0.8,        @csv.match('baz,bar', /,/), D
+    assert_in_delta 0.8,        @csv.match('foo,baz', /,/), D
+    assert_in_delta 0.8,        @csv.match('baz,foo', /,/), D
+    assert_in_delta 1,          @csv.match('foo,bar,baz', /,/), D
+    assert_in_delta 1,          @csv.match('foo,baz,bar', /,/), D
+    assert_in_delta 1,          @csv.match('baz,foo,bar', /,/), D
+    assert_in_delta 1,          @csv.match('baz,bar,foo', /,/), D
+    assert_in_delta 1,          @csv.match('bar,foo,baz', /,/), D
+    assert_in_delta 1,          @csv.match('bar,baz,foo', /,/), D
+    assert_in_delta 1,          @csv.match('foo,bar,baz', nil), D
+    assert_in_delta 0.9,        @csv.match('foo,baz,bar', nil), D
+    assert_in_delta 0.9,        @csv.match('foo,baz,bar'), D
+    assert_in_delta 0.9,        @csv.similar('foo,baz,bar'), D
+  end
+end
+  # vim: set et sw=2 ts=2: