amatch 0.3.0 → 0.4.1

data/ext/amatch_ext.c

@@ -3,24 +3,8 @@
 #include <ctype.h>
 #include "common.h"
 
-/*
- * Document-method: pattern
- *
- * call-seq: pattern -> pattern string
- *
- * Returns the current pattern string of this instance.
- */
-
-/*
- * Document-method: pattern=
- *
- * call-seq: pattern=(pattern)
- * 
- * Sets the current pattern string of this instance to <code>pattern</code>.
- */
-
-
-static VALUE rb_mAmatch, rb_mAmatchStringMethods, rb_cLevenshtein, rb_cSellers, rb_cHamming,
+static VALUE rb_mAmatch, rb_mAmatchStringMethods, rb_cLevenshtein,
+             rb_cDamerauLevenshtein, rb_cSellers, rb_cHamming,
              rb_cPairDistance, rb_cLongestSubsequence, rb_cLongestSubstring,
              rb_cJaro, rb_cJaroWinkler;
 
@@ -230,9 +214,11 @@ DEF_ITERATE_STRINGS(JaroWinkler)
  */
 
 #define COMPUTE_LEVENSHTEIN_DISTANCE                                        \
-    for (i = 1, c = 0, p = 1; i <= a_len; i++) {                            \
+    c = 0;                                                                  \
+    p = 0;                                                                  \
+    for (i = 1; i <= a_len; i++) {                                          \
         c = i % 2;                      /* current row */                   \
-        p = (i + 1) % 2;                /* previous row */                  \
+        p = (i - 1) % 2;                /* previous row */                  \
         v[c][0] = i;                    /* first column */                  \
         for (j = 1; j <= b_len; j++) {                                      \
             /* Bellman's principle of optimality: */                        \
@@ -245,8 +231,6 @@ DEF_ITERATE_STRINGS(JaroWinkler)
             }                                                               \
             v[c][j] = weight;                                               \
         }                                                                   \
-        p = c;                                                              \
-        c = (c + 1) % 2;                                                    \
     }
 
 static VALUE Levenshtein_match(General *amatch, VALUE string)
@@ -269,7 +253,7 @@ static VALUE Levenshtein_match(General *amatch, VALUE string)
 
     COMPUTE_LEVENSHTEIN_DISTANCE
 
-    result = INT2FIX(v[p][b_len]);
+    result = INT2FIX(v[c][b_len]);
 
     xfree(v[0]);
     xfree(v[1]);
@@ -287,6 +271,7 @@ static VALUE Levenshtein_similar(General *amatch, VALUE string)
 
     Check_Type(string, T_STRING);
     DONT_OPTIMIZE
+
     if (a_len == 0 && b_len == 0) return rb_float_new(1.0);
     if (a_len == 0 || b_len == 0) return rb_float_new(0.0);
     v[0] = ALLOC_N(int, b_len + 1);
@@ -299,12 +284,14 @@ static VALUE Levenshtein_similar(General *amatch, VALUE string)
     COMPUTE_LEVENSHTEIN_DISTANCE
 
     if (b_len > a_len) {
-        result = rb_float_new(1.0 - ((double) v[p][b_len]) / b_len);
+        result = rb_float_new(1.0 - ((double) v[c][b_len]) / b_len);
     } else {
-        result = rb_float_new(1.0 - ((double) v[p][b_len]) / a_len);
+        result = rb_float_new(1.0 - ((double) v[c][b_len]) / a_len);
     }
+
     xfree(v[0]);
     xfree(v[1]);
+
     return result;
 }
 
@@ -327,26 +314,159 @@ static VALUE Levenshtein_search(General *amatch, VALUE string)
     COMPUTE_LEVENSHTEIN_DISTANCE
 
     for (i = 0, min = a_len; i <= b_len; i++) {
-        if (v[p][i] < min) min = v[p][i];
+        if (v[c][i] < min) min = v[c][i];
     }
 
     result = INT2FIX(min);
 
     xfree(v[0]);
     xfree(v[1]);
-    
+
+    return result;
+}
+
+/*
+ * DamerauLevenshtein edit distances are computed here:
+ */
+
+#define COMPUTE_DAMERAU_LEVENSHTEIN_DISTANCE                                \
+    c = 0;                                                                  \
+    p = 0;                                                                  \
+    pp = 0;                                                                 \
+    for (i = 1; i <= a_len; i++) {                                          \
+        c = i % 3;                      /* current row */                   \
+        p = (i - 1) % 3;                /* previous row */                  \
+        pp = (i - 2) % 3;               /* previous previous row */         \
+        v[c][0] = i;                    /* first column */                  \
+        for (j = 1; j <= b_len; j++) {                                      \
+            /* Bellman's principle of optimality: */                        \
+            weight = v[p][j - 1] + (a_ptr[i - 1] == b_ptr[j - 1] ? 0 : 1);  \
+            if (weight > v[p][j] + 1) {                                     \
+                 weight = v[p][j] + 1;                                      \
+            }                                                               \
+            if (weight > v[c][j - 1] + 1) {                                 \
+                weight = v[c][j - 1] + 1;                                   \
+            }                                                               \
+            if (i > 2 && j > 2 && a_ptr[i - 1] == b_ptr[j - 2] && a_ptr[i - 2] == b_ptr[j - 1]) {\
+                if (weight > v[pp][j - 2]) {                                \
+                    weight = v[pp][j - 2] + (a_ptr[i - 1] == b_ptr[j - 1] ? 0 : 1);       \
+                }                                                           \
+            }                                                               \
+            v[c][j] = weight;                                               \
+        }                                                                   \
+    }
+
+static VALUE DamerauLevenshtein_match(General *amatch, VALUE string)
+{
+    VALUE result;
+    char *a_ptr, *b_ptr;
+    int a_len, b_len;
+    int *v[3], weight;
+    int  i, j, c, p, pp;
+
+    Check_Type(string, T_STRING);
+    DONT_OPTIMIZE
+
+    v[0] = ALLOC_N(int, b_len + 1);
+    v[1] = ALLOC_N(int, b_len + 1);
+    v[2] = ALLOC_N(int, b_len + 1);
+    for (i = 0; i <= b_len; i++) {
+        v[0][i] = i;
+        v[1][i] = i;
+        v[2][i] = i;
+    }
+
+    COMPUTE_DAMERAU_LEVENSHTEIN_DISTANCE
+
+    result = INT2FIX(v[c][b_len]);
+
+    xfree(v[0]);
+    xfree(v[1]);
+    xfree(v[2]);
+
     return result;
 }
 
+static VALUE DamerauLevenshtein_similar(General *amatch, VALUE string)
+{
+    VALUE result;
+    char *a_ptr, *b_ptr;
+    int a_len, b_len;
+    int *v[3], weight;
+    int  i, j, c, p, pp;
+
+    Check_Type(string, T_STRING);
+    DONT_OPTIMIZE
+
+    if (a_len == 0 && b_len == 0) return rb_float_new(1.0);
+    if (a_len == 0 || b_len == 0) return rb_float_new(0.0);
+    v[0] = ALLOC_N(int, b_len + 1);
+    v[1] = ALLOC_N(int, b_len + 1);
+    v[2] = ALLOC_N(int, b_len + 1);
+    for (i = 0; i <= b_len; i++) {
+        v[0][i] = i;
+        v[1][i] = i;
+        v[2][i] = i;
+    }
+
+    COMPUTE_DAMERAU_LEVENSHTEIN_DISTANCE
+
+    if (b_len > a_len) {
+        result = rb_float_new(1.0 - ((double) v[c][b_len]) / b_len);
+    } else {
+        result = rb_float_new(1.0 - ((double) v[c][b_len]) / a_len);
+    }
+
+    xfree(v[0]);
+    xfree(v[1]);
+    xfree(v[2]);
+
+    return result;
+}
+
+static VALUE DamerauLevenshtein_search(General *amatch, VALUE string)
+{
+    VALUE result;
+    char *a_ptr, *b_ptr;
+    int a_len, b_len;
+    int *v[3], weight, min;
+    int  i, j, c, p, pp;
+
+    Check_Type(string, T_STRING);
+    DONT_OPTIMIZE
+
+    v[0] = ALLOC_N(int, b_len + 1);
+    v[1] = ALLOC_N(int, b_len + 1);
+    v[2] = ALLOC_N(int, b_len + 1);
+    MEMZERO(v[0], int, b_len + 1);
+    MEMZERO(v[1], int, b_len + 1);
+    MEMZERO(v[2], int, b_len + 1);
+
+    COMPUTE_DAMERAU_LEVENSHTEIN_DISTANCE
+
+    for (i = 0, min = a_len; i <= b_len; i++) {
+        if (v[c][i] < min) min = v[c][i];
+    }
+
+    result = INT2FIX(min);
+
+    xfree(v[0]);
+    xfree(v[1]);
+    xfree(v[2]);
+
+    return result;
+}
 
 /*
  * Sellers edit distances are computed here:
  */
 
 #define COMPUTE_SELLERS_DISTANCE                                            \
-    for (i = 1, c = 0, p = 1; i <= a_len; i++) {                            \
+    c = 0;                                                                  \
+    p = 0;                                                                  \
+    for (i = 1; i <= a_len; i++) {                                          \
         c = i % 2;                      /* current row */                   \
-        p = (i + 1) % 2;                /* previous row */                  \
+        p = (i - 1) % 2;                /* previous row */                  \
         v[c][0] = i * amatch->deletion; /* first column */                  \
         for (j = 1; j <= b_len; j++) {                                      \
             /* Bellman's principle of optimality: */                        \
@@ -361,7 +481,6 @@ static VALUE Levenshtein_search(General *amatch, VALUE string)
             v[c][j] = weight;                                               \
         }                                                                   \
         p = c;                                                              \
-        c = (c + 1) % 2;                                                    \
     }
 
 static VALUE Sellers_match(Sellers *amatch, VALUE string)
@@ -411,9 +530,10 @@ static VALUE Sellers_similar(Sellers *amatch, VALUE string)
             max_weight = amatch->deletion;
         }
     }
-    
+
     Check_Type(string, T_STRING);
     DONT_OPTIMIZE
+
     if (a_len == 0 && b_len == 0) return rb_float_new(1.0);
     if (a_len == 0 || b_len == 0) return rb_float_new(0.0);
     v[0] = ALLOC_N(double, b_len + 1);
@@ -459,7 +579,7 @@ static VALUE Sellers_search(Sellers *amatch, VALUE string)
     result = rb_float_new(min);
     xfree(v[0]);
     xfree(v[1]);
-    
+
     return result;
 }
 
@@ -470,34 +590,32 @@ static VALUE Sellers_search(Sellers *amatch, VALUE string)
 static VALUE PairDistance_match(PairDistance *amatch, VALUE string, VALUE regexp, int use_regexp)
 {
     double result;
-    VALUE tokens;
-    PairArray *pair_array;
-    
+    VALUE string_tokens, tokens;
+    PairArray *pattern_pair_array, *pair_array;
+
     Check_Type(string, T_STRING);
     if (!NIL_P(regexp) || use_regexp) {
         tokens = rb_funcall(
             rb_str_new(amatch->pattern, amatch->pattern_len),
             id_split, 1, regexp
         );
-        if (!amatch->pattern_pair_array) {
-            amatch->pattern_pair_array = PairArray_new(tokens);
-        } else {
-            pair_array_reactivate(amatch->pattern_pair_array);
-        }
-        tokens = rb_funcall(string, id_split, 1, regexp);
-        pair_array = PairArray_new(tokens);
+        string_tokens = rb_funcall(string, id_split, 1, regexp);
     } else {
         VALUE tmp = rb_str_new(amatch->pattern, amatch->pattern_len);
         tokens = rb_ary_new4(1, &tmp);
-        if (!amatch->pattern_pair_array) {
-            amatch->pattern_pair_array = PairArray_new(tokens);
-        } else {
-            pair_array_reactivate(amatch->pattern_pair_array);
-        }
-        tokens = rb_ary_new4(1, &string);
-        pair_array = PairArray_new(tokens);
+        string_tokens = rb_ary_new4(1, &string);
+    }
+
+    if (!amatch->pattern_pair_array) {
+        pattern_pair_array = PairArray_new(tokens);
+        amatch->pattern_pair_array = pattern_pair_array;
+    } else {
+        pattern_pair_array = amatch->pattern_pair_array;
+        pair_array_reactivate(amatch->pattern_pair_array);
     }
-    result = pair_array_match(amatch->pattern_pair_array, pair_array);
+    pair_array = PairArray_new(string_tokens);
+
+    result = pair_array_match(pattern_pair_array, pair_array);
     pair_array_destroy(pair_array);
     return rb_float_new(result);
 }
@@ -520,7 +638,7 @@ static VALUE Hamming_match(General *amatch, VALUE string)
     char *a_ptr, *b_ptr;
     int a_len, b_len;
     int i, result;
-    
+
     Check_Type(string, T_STRING);
     OPTIMIZE_TIME
     COMPUTE_HAMMING_DISTANCE
@@ -532,7 +650,7 @@ static VALUE Hamming_similar(General *amatch, VALUE string)
     char *a_ptr, *b_ptr;
     int a_len, b_len;
     int i, result;
-    
+
     Check_Type(string, T_STRING);
     OPTIMIZE_TIME
     if (a_len == 0 && b_len == 0) return rb_float_new(1.0);
@@ -572,7 +690,7 @@ static VALUE LongestSubsequence_match(General *amatch, VALUE string)
     char *a_ptr, *b_ptr;
     int a_len, b_len;
     int result, c, p, i, j, *l[2];
-    
+
     Check_Type(string, T_STRING);
     OPTIMIZE_TIME
 
@@ -586,7 +704,7 @@ static VALUE LongestSubsequence_similar(General *amatch, VALUE string)
     char *a_ptr, *b_ptr;
     int a_len, b_len;
     int result, c, p, i, j, *l[2];
-    
+
     Check_Type(string, T_STRING);
     OPTIMIZE_TIME
 
@@ -626,7 +744,7 @@ static VALUE LongestSubstring_match(General *amatch, VALUE string)
     char *a_ptr, *b_ptr;
     int a_len, b_len;
     int result, c, p, i, j, *l[2];
-    
+
     Check_Type(string, T_STRING);
     OPTIMIZE_TIME
     if (a_len == 0 || b_len == 0) return INT2FIX(0);
@@ -639,7 +757,7 @@ static VALUE LongestSubstring_similar(General *amatch, VALUE string)
     char *a_ptr, *b_ptr;
     int a_len, b_len;
     int result, c, p, i, j, *l[2];
-    
+
     Check_Type(string, T_STRING);
     OPTIMIZE_TIME
     if (a_len == 0 && b_len == 0) return rb_float_new(1.0);
@@ -771,7 +889,7 @@ static VALUE JaroWinkler_match(JaroWinkler *amatch, VALUE string)
  * Ruby API
  */
 
- /* 
+ /*
   * Document-class: Amatch::Levenshtein
   *
   * The Levenshtein edit distance is defined as the minimal costs involved to
@@ -804,7 +922,7 @@ DEF_CONSTRUCTOR(Levenshtein, General)
 
 /*
  * call-seq: match(strings) -> results
- * 
+ *
  * Uses this Amatch::Levenshtein instance to match Amatch::Levenshtein#pattern
  * against <code>strings</code>. It returns the number operations, the Sellers
  * distance. <code>strings</code> has to be either a String or an Array of
@@ -812,14 +930,14 @@ DEF_CONSTRUCTOR(Levenshtein, General)
  * Floats respectively.
  */
 static VALUE rb_Levenshtein_match(VALUE self, VALUE strings)
-{                                                                            
+{
     GET_STRUCT(General)
     return General_iterate_strings(amatch, strings, Levenshtein_match);
 }
 
 /*
  * call-seq: similar(strings) -> results
- * 
+ *
  * Uses this Amatch::Levenshtein instance to match  Amatch::Levenshtein#pattern
  * against <code>strings</code>, and compute a Levenshtein distance metric
  * number between 0.0 for very unsimilar strings and 1.0 for an exact match.
@@ -828,14 +946,14 @@ static VALUE rb_Levenshtein_match(VALUE self, VALUE strings)
  * respectively.
  */
 static VALUE rb_Levenshtein_similar(VALUE self, VALUE strings)
-{                                                                            
+{
     GET_STRUCT(General)
     return General_iterate_strings(amatch, strings, Levenshtein_similar);
 }
 
 /*
  * call-seq: levenshtein_similar(strings) -> results
- * 
+ *
  * If called on a String, this string is used as a Amatch::Levenshtein#pattern
  * to match against <code>strings</code>. It returns a Levenshtein distance
  * metric number between 0.0 for very unsimilar strings and 1.0 for an exact
@@ -851,7 +969,7 @@ static VALUE rb_str_levenshtein_similar(VALUE self, VALUE strings)
 
 /*
  * call-seq: search(strings) -> results
- * 
+ *
  * searches Amatch::Levenshtein#pattern in <code>strings</code> and returns the
  * edit distance (the sum of character operations) as a Fixnum value, by greedy
  * trimming prefixes or postfixes of the match. <code>strings</code> has
@@ -859,12 +977,105 @@ static VALUE rb_str_levenshtein_similar(VALUE self, VALUE strings)
  * <code>results</code> is either a Float or an Array of Floats respectively.
  */
 static VALUE rb_Levenshtein_search(VALUE self, VALUE strings)
-{                                                                            
+{
     GET_STRUCT(General)
     return General_iterate_strings(amatch, strings, Levenshtein_search);
 }
 
-/* 
+/*
+ * Document-class: Amatch::DamerauLevenshtein
+ * XXX
+ * The DamerauLevenshtein edit distance is defined as the minimal costs
+ * involved to transform one string into another by using three elementary
+ * operations: deletion, insertion and substitution of a character. To
+ * transform "water" into "wine", for instance, you have to substitute "a" ->
+ * "i": "witer", "t" -> "n": "winer" and delete "r": "wine". The edit distance
+ * between "water" and "wine" is 3, because you have to apply three
+ * operations. The edit distance between "wine" and "wine" is 0 of course: no
+ * operation is necessary for the transformation -- they're already the same
+ * string. It's easy to see that more similar strings have smaller edit
+ * distances than strings that differ a lot.
+ */
+
+DEF_RB_FREE(DamerauLevenshtein, General)
+
+/*
+ * call-seq: new(pattern)
+  * XXX
+ * Creates a new Amatch::DamerauLevenshtein instance from <code>pattern</code>.
+ */
+static VALUE rb_DamerauLevenshtein_initialize(VALUE self, VALUE pattern)
+{
+    GET_STRUCT(General)
+    General_pattern_set(amatch, pattern);
+    return self;
+}
+
+DEF_CONSTRUCTOR(DamerauLevenshtein, General)
+
+/*
+ * call-seq: match(strings) -> results
+ * XXX
+ * Uses this Amatch::DamerauLevenshtein instance to match Amatch::DamerauLevenshtein#pattern
+ * against <code>strings</code>. It returns the number operations, the Sellers
+ * distance. <code>strings</code> has to be either a String or an Array of
+ * Strings. The returned <code>results</code> is either a Float or an Array of
+ * Floats respectively.
+ */
+static VALUE rb_DamerauLevenshtein_match(VALUE self, VALUE strings)
+{
+    GET_STRUCT(General)
+    return General_iterate_strings(amatch, strings, DamerauLevenshtein_match);
+}
+
+/*
+ * call-seq: similar(strings) -> results
+ * XXX
+ * Uses this Amatch::DamerauLevenshtein instance to match  Amatch::DamerauLevenshtein#pattern
+ * against <code>strings</code>, and compute a DamerauLevenshtein distance metric
+ * number between 0.0 for very unsimilar strings and 1.0 for an exact match.
+ * <code>strings</code> has to be either a String or an Array of Strings. The
+ * returned <code>results</code> is either a Fixnum or an Array of Fixnums
+ * respectively.
+ */
+static VALUE rb_DamerauLevenshtein_similar(VALUE self, VALUE strings)
+{
+    GET_STRUCT(General)
+    return General_iterate_strings(amatch, strings, DamerauLevenshtein_similar);
+}
+
+/*
+ * call-seq: levenshtein_similar(strings) -> results
+ * XXX
+ * If called on a String, this string is used as a Amatch::DamerauLevenshtein#pattern
+ * to match against <code>strings</code>. It returns a DamerauLevenshtein distance
+ * metric number between 0.0 for very unsimilar strings and 1.0 for an exact
+ * match. <code>strings</code> has to be either a String or an Array of
+ * Strings. The returned <code>results</code> is either a Float or an Array of
+ * Floats respectively.
+ */
+static VALUE rb_str_damerau_levenshtein_similar(VALUE self, VALUE strings)
+{
+    VALUE amatch = rb_DamerauLevenshtein_new(rb_cDamerauLevenshtein, self);
+    return rb_DamerauLevenshtein_similar(amatch, strings);
+}
+
+/*
+ * call-seq: search(strings) -> results
+ * XXX
+ * searches Amatch::DamerauLevenshtein#pattern in <code>strings</code> and returns the
+ * edit distance (the sum of character operations) as a Fixnum value, by greedy
+ * trimming prefixes or postfixes of the match. <code>strings</code> has
+ * to be either a String or an Array of Strings. The returned
+ * <code>results</code> is either a Float or an Array of Floats respectively.
+ */
+static VALUE rb_DamerauLevenshtein_search(VALUE self, VALUE strings)
+{
+    GET_STRUCT(General)
+    return General_iterate_strings(amatch, strings, DamerauLevenshtein_search);
+}
+
+/*
  * Document-class: Amatch::Sellers
  *
  * The Sellers edit distance is very similar to the Levenshtein edit distance.
@@ -983,14 +1194,14 @@ DEF_CONSTRUCTOR(Sellers, Sellers)
  * Document-method: pattern=
  *
  * call-seq: pattern=(pattern)
- * 
+ *
  * Sets the current pattern string of this Amatch::Sellers instance to
  * <code>pattern</code>.
  */
 
 /*
  * call-seq: match(strings) -> results
- * 
+ *
  * Uses this Amatch::Sellers instance to match Sellers#pattern against
  * <code>strings</code>, while taking into account the given weights. It
  * returns the number of weighted character operations, the Sellers distance.
@@ -999,14 +1210,14 @@ DEF_CONSTRUCTOR(Sellers, Sellers)
  * respectively.
  */
 static VALUE rb_Sellers_match(VALUE self, VALUE strings)
-{                                                                            
+{
     GET_STRUCT(Sellers)
     return Sellers_iterate_strings(amatch, strings, Sellers_match);
 }
 
 /*
  * call-seq: similar(strings) -> results
- * 
+ *
  * Uses this Amatch::Sellers instance to match Amatch::Sellers#pattern
  * against <code>strings</code> (taking into account the given weights), and
  * compute a Sellers distance metric number between 0.0 for very unsimilar
@@ -1016,7 +1227,7 @@ static VALUE rb_Sellers_match(VALUE self, VALUE strings)
  * respectively.
  */
 static VALUE rb_Sellers_similar(VALUE self, VALUE strings)
-{                                                                            
+{
     GET_STRUCT(Sellers)
     return Sellers_iterate_strings(amatch, strings, Sellers_similar);
 }
@@ -1031,12 +1242,12 @@ static VALUE rb_Sellers_similar(VALUE self, VALUE strings)
  * <code>results</code> is either a Float or an Array of Floats respectively.
  */
 static VALUE rb_Sellers_search(VALUE self, VALUE strings)
-{                                                                            
+{
     GET_STRUCT(Sellers)
     return Sellers_iterate_strings(amatch, strings, Sellers_search);
 }
 
-/* 
+/*
  * Document-class: Amatch::PairDistance
  *
  * The pair distance between two strings is based on the number of adjacent
@@ -1047,7 +1258,7 @@ static VALUE rb_Sellers_search(VALUE self, VALUE strings)
  * are more dissimilar. The advantage of considering adjacent characters, is to
  * take account not only of the characters, but also of the character ordering
  * in the original strings.
- * 
+ *
  * This metric is very capable to find similarities in natural languages.
  * It is explained in more detail in Simon White's article "How to Strike a
  * Match", located at this url:
@@ -1074,7 +1285,7 @@ DEF_CONSTRUCTOR(PairDistance, PairDistance)
 
 /*
  * call-seq: match(strings, regexp = /\s+/) -> results
- * 
+ *
  * Uses this Amatch::PairDistance instance to match  PairDistance#pattern against
  * <code>strings</code>. It returns the pair distance measure, that is a
  * returned value of 1.0 is an exact match, partial matches are lower
@@ -1090,7 +1301,7 @@ DEF_CONSTRUCTOR(PairDistance, PairDistance)
  * Array of Floats respectively.
  */
 static VALUE rb_PairDistance_match(int argc, VALUE *argv, VALUE self)
-{                                                                            
+{
     VALUE result, strings, regexp = Qnil;
     int use_regexp;
     GET_STRUCT(PairDistance)
@@ -1148,7 +1359,7 @@ static VALUE rb_str_pair_distance_similar(int argc, VALUE *argv, VALUE self)
     }
 }
 
-/* 
+/*
  * Document-class: Amatch::Hamming
  *
  *  This class computes the Hamming distance between two strings.
@@ -1178,7 +1389,7 @@ DEF_CONSTRUCTOR(Hamming, General)
 
 /*
  * call-seq: match(strings) -> results
- * 
+ *
  * Uses this Amatch::Hamming instance to match Amatch::Hamming#pattern against
  * <code>strings</code>, that is compute the hamming distance between
  * <code>pattern</code> and <code>strings</code>. <code>strings</code> has to
@@ -1186,7 +1397,7 @@ DEF_CONSTRUCTOR(Hamming, General)
  * is either a Fixnum or an Array of Fixnums respectively.
  */
 static VALUE rb_Hamming_match(VALUE self, VALUE strings)
-{                                                                            
+{
     GET_STRUCT(General)
     return General_iterate_strings(amatch, strings, Hamming_match);
 }
@@ -1202,7 +1413,7 @@ static VALUE rb_Hamming_match(VALUE self, VALUE strings)
  * respectively.
  */
 static VALUE rb_Hamming_similar(VALUE self, VALUE strings)
-{                                                                            
+{
     GET_STRUCT(General)
     return General_iterate_strings(amatch, strings, Hamming_similar);
 }
@@ -1224,7 +1435,7 @@ static VALUE rb_str_hamming_similar(VALUE self, VALUE strings)
 }
 
 
-/* 
+/*
  * Document-class: Amatch::LongestSubsequence
  *
  *  This class computes the length of the longest subsequence common to two
@@ -1254,7 +1465,7 @@ DEF_CONSTRUCTOR(LongestSubsequence, General)
 
 /*
  * call-seq: match(strings) -> results
- * 
+ *
  * Uses this Amatch::LongestSubsequence instance to match
  * LongestSubsequence#pattern against <code>strings</code>, that is compute the
  * length of the longest common subsequence. <code>strings</code> has to be
@@ -1262,14 +1473,14 @@ DEF_CONSTRUCTOR(LongestSubsequence, General)
  * is either a Fixnum or an Array of Fixnums respectively.
  */
 static VALUE rb_LongestSubsequence_match(VALUE self, VALUE strings)
-{                                                                            
+{
     GET_STRUCT(General)
     return General_iterate_strings(amatch, strings, LongestSubsequence_match);
 }
 
 /*
  * call-seq: similar(strings) -> results
- * 
+ *
  * Uses this Amatch::LongestSubsequence instance to match
  * Amatch::LongestSubsequence#pattern against <code>strings</code>, and compute
  * a longest substring distance metric number between 0.0 for very unsimilar
@@ -1278,7 +1489,7 @@ static VALUE rb_LongestSubsequence_match(VALUE self, VALUE strings)
  * a Fixnum or an Array of Fixnums
  */
 static VALUE rb_LongestSubsequence_similar(VALUE self, VALUE strings)
-{                                                                            
+{
     GET_STRUCT(General)
     return General_iterate_strings(amatch, strings, LongestSubsequence_similar);
 }
@@ -1294,12 +1505,12 @@ static VALUE rb_LongestSubsequence_similar(VALUE self, VALUE strings)
  * is either a Float or an Array of Floats respectively.
  */
 static VALUE rb_str_longest_subsequence_similar(VALUE self, VALUE strings)
-{                                                                            
+{
     VALUE amatch = rb_LongestSubsequence_new(rb_cLongestSubsequence, self);
     return rb_LongestSubsequence_similar(amatch, strings);
 }
 
-/* 
+/*
  * Document-class: Amatch::LongestSubstring
  *
  * The longest common substring is the longest substring, that is part of
@@ -1310,7 +1521,7 @@ static VALUE rb_str_longest_subsequence_similar(VALUE self, VALUE strings)
  * The longest common substring between 'string' and 'string' is 'string'
  * again, thus the longest common substring length is 6. The longest common
  * substring between 'string' and 'storing' is 'ring', thus the longest common
- * substring length is 4. 
+ * substring length is 4.
  */
 
 DEF_RB_FREE(LongestSubstring, General)
@@ -1331,7 +1542,7 @@ DEF_CONSTRUCTOR(LongestSubstring, General)
 
 /*
  * call-seq: match(strings) -> results
- * 
+ *
  * Uses this Amatch::LongestSubstring instance to match
  * LongestSubstring#pattern against <code>strings</code>, that is compute the
  * length of the longest common substring. <code>strings</code> has to be
@@ -1346,7 +1557,7 @@ static VALUE rb_LongestSubstring_match(VALUE self, VALUE strings)
 
 /*
  * call-seq: similar(strings) -> results
- * 
+ *
  * Uses this Amatch::LongestSubstring instance to match
  * Amatch::LongestSubstring#pattern against <code>strings</code>, and compute a
  * longest substring distance metric number between 0.0 for very unsimilar
@@ -1372,11 +1583,11 @@ static VALUE rb_LongestSubstring_similar(VALUE self, VALUE strings)
  * is either a Float or an Array of Floats respectively.
  */
 static VALUE rb_str_longest_substring_similar(VALUE self, VALUE strings)
-{                                                                            
+{
     VALUE amatch = rb_LongestSubstring_new(rb_cLongestSubstring, self);
     return rb_LongestSubstring_similar(amatch, strings);
 }
-  
+
 /*
  * Document-class: Amatch::Jaro
  *
@@ -1573,6 +1784,17 @@ void Init_amatch_ext()
     rb_define_method(rb_cLevenshtein, "similar", rb_Levenshtein_similar, 1);
     rb_define_method(rb_mAmatchStringMethods, "levenshtein_similar", rb_str_levenshtein_similar, 1);
 
+    /* DamerauLevenshtein */
+    rb_cDamerauLevenshtein = rb_define_class_under(rb_mAmatch, "DamerauLevenshtein", rb_cObject);
+    rb_define_alloc_func(rb_cDamerauLevenshtein, rb_DamerauLevenshtein_s_allocate);
+    rb_define_method(rb_cDamerauLevenshtein, "initialize", rb_DamerauLevenshtein_initialize, 1);
+    rb_define_method(rb_cDamerauLevenshtein, "pattern", rb_General_pattern, 0);
+    rb_define_method(rb_cDamerauLevenshtein, "pattern=", rb_General_pattern_set, 1);
+    rb_define_method(rb_cDamerauLevenshtein, "match", rb_DamerauLevenshtein_match, 1);
+    rb_define_method(rb_cDamerauLevenshtein, "search", rb_DamerauLevenshtein_search, 1);
+    rb_define_method(rb_cDamerauLevenshtein, "similar", rb_DamerauLevenshtein_similar, 1);
+    rb_define_method(rb_mAmatchStringMethods, "damerau_levenshtein_similar", rb_str_damerau_levenshtein_similar, 1);
+
     /* Sellers */
     rb_cSellers = rb_define_class_under(rb_mAmatch, "Sellers", rb_cObject);
     rb_define_alloc_func(rb_cSellers, rb_Sellers_s_allocate);