amatch 0.3.1 → 0.4.0

data/README.md

@@ -0,0 +1,124 @@
+# amatch - Approximate Matching Extension for Ruby
+
+## Description
+
+This is a collection of classes that can be used for Approximate
+matching, searching, and comparing of Strings. They implement algorithms
+that compute the Levenshtein edit distance, Sellers edit distance, the
+Hamming distance, the longest common subsequence length, the longest common
+substring length, the pair distance metric, the Jaro-Winkler metric.
+
+## Installation
+
+To install this extension as a gem type
+
+ # gem install amatch
+
+into the shell.
+
+## Download
+
+The homepage of this library is located at
+
+* https://github.com/flori/amatch
+
+## Examples
+
+    require 'amatch'
+    # => true
+    include Amatch
+    # => Object
+    
+    m = Sellers.new("pattern")
+    # => #<Amatch::Sellers:0x40366324>
+    m.match("pattren")
+    # => 2.0
+    m.substitution = m.insertion = 3
+    # => 3
+    m.match("pattren")
+    # => 4.0
+    m.reset_weights
+    # => #<Amatch::Sellers:0x40366324>
+    m.match(["pattren","parent"])
+    # => [2.0, 4.0]
+    m.search("abcpattrendef")
+    # => 2.0
+    
+    m = Levenshtein.new("pattern")
+    # => #<Amatch::Levenshtein:0x4035919c>
+    m.match("pattren")
+    # => 2
+    m.search("abcpattrendef")
+    # => 2
+    "pattern language".levenshtein_similar("language of patterns")
+    # => 0.2
+    
+    m = Amatch::DamerauLevenshtein.new("pattern")
+    # => #<Amatch::DamerauLevenshtein:0x007fc3483dd278>
+    m.match("pattren")
+    # => 1
+    "pattern language".damerau_levenshtein_similar("language of patterns")
+    # => 0.19999999999999996
+    
+    m = Hamming.new("pattern")
+    # => #<Amatch::Hamming:0x40350858>
+    m.match("pattren")
+    # => 2
+    "pattern language".hamming_similar("language of patterns")
+    # => 0.1
+    
+    m = PairDistance.new("pattern")
+    # => #<Amatch::PairDistance:0x40349be8>
+    m.match("pattr en")
+    # => 0.545454545454545
+    m.match("pattr en", nil)
+    # => 0.461538461538462
+    m.match("pattr en", /t+/)
+    # => 0.285714285714286
+    "pattern language".pair_distance_similar("language of patterns")
+    # => 0.928571428571429
+    
+    m = LongestSubsequence.new("pattern")
+    # => #<Amatch::LongestSubsequence:0x4033e900>
+    m.match("pattren")
+    # => 6
+    "pattern language".longest_subsequence_similar("language of patterns")
+    # => 0.4
+    
+    m = LongestSubstring.new("pattern")
+    # => #<Amatch::LongestSubstring:0x403378d0>
+    m.match("pattren")
+    # => 4
+    "pattern language".longest_substring_similar("language of patterns")
+    # => 0.4
+   
+    m = Jaro.new("pattern")
+    # => #<Amatch::Jaro:0x363b70>
+    m.match("paTTren")
+    # => 0.952380952380952
+    m.ignore_case = false
+    m.match("paTTren")
+    # => 0.742857142857143
+    "pattern language".jaro_similar("language of patterns")
+    # => 0.672222222222222
+   
+    m = JaroWinkler.new("pattern")
+    # #<Amatch::JaroWinkler:0x3530b8>
+    m.match("paTTren")
+    # => 0.971428571712403
+    m.ignore_case = false
+    m.match("paTTren")
+    # => 0.79428571505206
+    m.scaling_factor = 0.05
+    m.match("pattren")
+    # => 0.961904762046678
+    "pattern language".jarowinkler_similar("language of patterns")
+    # => 0.672222222222222
+
+## Author
+
+Florian Frank mailto:flori@ping.de
+
+## License
+
+Apache License, Version 2.0 – See the COPYING file in the source archive.

data/Rakefile

@@ -13,22 +13,15 @@ Amatch is a library for approximate string matching and searching in strings.
 Several algorithms can be used to do this, and it's also possible to compute a
 similarity metric number between 0.0 and 1.0 for two given strings.
 EOT
-  executables << 'agrep.rb'
+  executables << 'agrep' << 'dupfind'
   bindir      'bin'
   test_dir    'tests'
-  ignore      '.*.sw[pon]', 'pkg', 'Gemfile.lock', '.AppleDouble', '.rbx', '.bundle'
+  ignore      '.*.sw[pon]', 'pkg', 'Gemfile.lock', '.AppleDouble', '.rbx', 'Makefile'
   title       "#{name.camelize} - Approximate Matching"
-  readme      'README.rdoc'
+  readme      'README.md'
   require_paths %w[lib ext]
   dependency             'tins',      '~>1.0'
+  dependency             'mize'
   development_dependency 'test-unit', '~>3.0'
-  licenses << 'GPL'
-
-  install_library do
-    libdir = CONFIG["sitelibdir"]
-    src, = Dir['ext/amatch.*'].reject { |x| x =~ /\.[co]$/ }
-    install(src, File.join(libdir, File.basename(src)), :verbose => true)
-    mkdir_p dst = File.join(libdir, 'amatch')
-    install('lib/amatch/version.rb', File.join(dst, 'version.rb'), :verbose => true)
-  end
+  licenses << 'Apache-2.0'
 end

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/bin/{agrep.rb → agrep}

@@ -15,15 +15,21 @@ end
 
 class Amatch::Levenshtein
   def search_relative(strings)
-    search(strings).to_f / pattern.size
+    if Array === strings
+      search(strings).map { |s| s.to_f / pattern.size }
+    else
+      search(strings).to_f / pattern.size
+    end
   end
 end
 
+$algorithm = 'Levenshtein'
 $distance = 1
 $mode = :search
 begin
   parser = GetoptLong.new
   options = [
+    [ '--algorithm',  '-a',  GetoptLong::REQUIRED_ARGUMENT ],
     [ '--distance',   '-d',  GetoptLong::REQUIRED_ARGUMENT ],
     [ '--relative',   '-r',  GetoptLong::NO_ARGUMENT ],
     [ '--verbose',    '-v',  GetoptLong::NO_ARGUMENT ],
@@ -33,6 +39,8 @@ begin
   parser.each_option do |name, arg|
     name = name.sub(/^--/, '')
     case name
+    when 'algorithm'
+      $algorithm = arg
     when 'distance'
       $distance = arg.to_f
     when 'relative'
@@ -48,7 +56,7 @@ rescue
 end
 pattern = ARGV.shift or usage('Pattern needed!', options)
 
-matcher = Amatch::Levenshtein.new(pattern)
+matcher = Amatch.const_get($algorithm).new(pattern)
 size = 0
 start = Time.new
 if ARGV.size > 0 then
@@ -56,9 +64,12 @@ if ARGV.size > 0 then
     File.stat(filename).file? or next
     size += File.size(filename)
     begin
-      File.open(filename, 'r').each_line do |line|
-        if matcher.__send__($mode, line) <= $distance
-          puts "#{filename}:#{line}"
+      File.open(filename, 'r').each_line.each_slice(1000) do |lines|
+        results = matcher.__send__($mode, lines) 
+        lines.zip(results) do |line, r|
+          if r <= $distance
+            puts "#{filename}:#{line}"
+          end
         end
       end
     rescue
@@ -66,10 +77,13 @@ if ARGV.size > 0 then
     end
   end
 else
-  STDIN.each_line do |line|
-    size += line.size
-    if matcher.__send__($mode, line) <= $distance
-      puts line
+  STDIN.each_line.each_slice(1000) do |lines|
+    size += lines.size
+    results = matcher.__send__($mode, lines)
+    lines.zip(results) do |line, r|
+      if r <= $distance
+        puts line
+      end
     end
   end
 end

data/bin/dupfind

@@ -0,0 +1,153 @@
+#! /usr/bin/env ruby
+
+require 'tins/go'
+include Tins::GO
+require 'tins/minimize'
+class Array
+  include Tins::Minimize
+end
+require 'amatch'
+begin
+  require 'infobar'
+rescue LoadError
+  warn "Please install gem infobar to run this executable!"
+  exit 1
+end
+
+def usage
+  puts <<EOT
+Usage: #{File.basename($0)} [OPTIONS] FILE
+
+ -a ALGO     Amatch matching algorithm
+ -p LIMIT    more than p similarity to be a match
+ -R NUMBER   skip NUMBER mismatch for building ranges
+ -r NUMBER   minimum length to be counted as a range
+ -i          compute a PNG per file
+
+Repor$ bugs to <flori@ping.de>.
+EOT
+  exit 0
+end
+
+class FindDuplicates
+  def initialize(algo, p_lim, filename)
+    @algo, @p_lim, @filename = algo, p_lim, filename
+  end
+
+  attr_reader :filename
+
+  attr_reader :algo
+
+  attr_reader :p_lim
+
+  memoize method:
+  def lines
+    File.readlines(filename)
+  end
+
+  memoize method:
+  def matrix
+    result = lines.with_infobar(label: filename, output: STDERR).map do |l1|
+      +infobar
+      a = algo.new(l1)
+      r = a.similar(lines)
+      r.map! { |s| s >= p_lim ? ?1 : ?0 }
+      r.join
+    end
+    infobar.finish
+    infobar.newline
+    result
+  end
+
+  def pbm(output: $>)
+    output << <<HEADER
+P1
+#{matrix.size} #{matrix.size}
+HEADER
+    output << matrix.map { |line| line.each_char.to_a * ' ' } * ?\n
+    self
+  end
+
+  def png(output: $>)
+    IO.popen("pnmtopng", 'w+') do |conv|
+      pbm(output: conv)
+      conv.close_write
+      output.write(conv.read)
+    end
+    self
+  end
+
+  def create_image
+    suffix = Regexp.quote(File.extname(filename))
+    f = filename.sub(/(#{suffix}|)\z/, '.png')
+    File.open(f, 'wb') do |output|
+      png(output: output)
+      infobar.puts "Writing output to #{f.inspect}."
+    end
+    self
+  end
+
+  def similar_ranges(min_range: 3, skip_range: 0)
+    set = 0
+    ranges = { set => [] }
+    m = matrix
+    n = m.size
+    skip_count = 0
+    n.downto(1) do |h|
+      (n - h + 1).upto(n - 1) do |k|
+        i = k
+        j = k - (n - h + 1)
+        if m[i][j] == ?1
+          skip_count = 0
+          ranges[set] << [ i, j ]
+        elsif !ranges[set].empty? && skip_count < skip_range
+          skip_count += 1
+        else
+          skip_count = 0
+          ranges[set].empty? or ranges[set += 1] = []
+        end
+      end
+      skip_count = 0
+      ranges[set].empty? or ranges[set += 1] = []
+    end
+    ranges.each { |_, r|
+      r.flatten!
+      r.sort!
+      r.map! { |x| x + 1 }
+      r.minimize!
+      r.reject! { |s| s.size < min_range }
+    }.reject! { |_, r| r.empty? }
+    unions = []
+    while !ranges.empty?
+      _, r = ranges.first
+      equivalent = ranges.reject { |_, v| (v & r).empty? }
+      unions << equivalent.values.flatten.uniq
+      ranges.delete_if { |k, _| equivalent.keys.include?(k) }
+    end
+    unions.each do |r|
+      r.map! do |x|
+        "#{filename}:#{x.begin}-#{x.end}"
+      end
+    end
+    unions
+  end
+end
+
+opts = go 'a:p:R:r:ih'
+
+usage if opts[?h]
+algo       = Amatch.const_get(opts[?a] || 'Levenshtein')
+p_lim      = (opts[?p] || 0.95).to_f
+min_range  = (opts[?r] || 3).to_i
+skip_range = opts[?R].to_i
+ARGV.empty? and usage
+
+filenames = ARGV.inject([]) { |s, f| s.concat(Dir[f]) }
+for filename in filenames
+  finder = FindDuplicates.new(algo, p_lim, filename)
+  opts[?i] and finder.create_image
+  for s in finder.similar_ranges(min_range: min_range, skip_range: skip_range)
+    infobar.reset
+    puts s, ?\n
+  end
+end

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,7 +590,7 @@ 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, string_tokens;
+    VALUE string_tokens, tokens;
     PairArray *pattern_pair_array, *pair_array;
 
     Check_Type(string, T_STRING);
@@ -518,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
@@ -530,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);
@@ -570,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
 
@@ -584,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
 
@@ -624,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);
@@ -637,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);
@@ -769,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
@@ -802,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
@@ -810,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.
@@ -826,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
@@ -849,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
@@ -857,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.
@@ -981,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.
@@ -997,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
@@ -1014,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);
 }
@@ -1029,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
@@ -1045,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:
@@ -1072,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
@@ -1088,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)
@@ -1146,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.
@@ -1176,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
@@ -1184,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);
 }
@@ -1200,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);
 }
@@ -1222,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
@@ -1252,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
@@ -1260,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
@@ -1276,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);
 }
@@ -1292,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
@@ -1308,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)
@@ -1329,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
@@ -1344,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
@@ -1370,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
  *
@@ -1571,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);