amatch 0.2.3 → 0.2.4

data/CHANGES

@@ -1,3 +1,7 @@
+2009-08-25 (0.2.4)
+    * Included Jaro and Jaro-Winkler metrics implementation of Kevin Ballard
+      <kevin@rapleaf.com>. Thanks a lot.
+    * Made the extension compile under Ruby 1.9.
 2006-06-25 (0.2.3)
     * Fixed agrep.rb to use the new API.
 2005-10-11 (0.2.2)

data/{GPL → COPYING}

@@ -1,12 +1,12 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
 
  Copyright (C) 1989, 1991 Free Software Foundation, Inc.
                        59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
-			    Preamble
+                            Preamble
 
   The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
@@ -56,7 +56,7 @@ patent must be licensed for everyone's free use or not licensed at all.
   The precise terms and conditions for copying, distribution and
 modification follow.
 
-		    GNU GENERAL PUBLIC LICENSE
+                    GNU GENERAL PUBLIC LICENSE
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
   0. This License applies to any program or other work which contains
@@ -255,7 +255,7 @@ make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 
-			    NO WARRANTY
+                            NO WARRANTY
 
   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
@@ -277,9 +277,9 @@ YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 
-		     END OF TERMS AND CONDITIONS
+                     END OF TERMS AND CONDITIONS
 
-	    How to Apply These Terms to Your New Programs
+            How to Apply These Terms to Your New Programs
 
   If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it

data/README

@@ -0,0 +1,25 @@
+Installation
+============
+
+Just type into the command line as root:
+
+# ruby install.rb
+
+If you have installed rake (rake.rubyforge.org), you can also type:
+
+# rake install
+
+To install this extension as a gem type
+
+# gem install amatch
+
+Author
+======
+
+Florian Frank <flori@ping.de>
+
+License
+=======
+
+GNU General Public License, Version 2 (GPLv2)
+

data/Rakefile

@@ -1,32 +1,33 @@
-# vim: set et sw=2 ts=2:
-require 'rake/clean'
-require 'rake/testtask'
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
-require 'rbconfig'
+# vim: set filetype=ruby et sw=2 ts=2:
 
+begin
+  require 'rake/gempackagetask'
+rescue LoadError
+end
+require 'rbconfig'
 include Config
+require 'rake/clean'
+CLEAN.include 'coverage', 'doc'
+require 'rake/testtask'
 
+MAKE        = ENV['MAKE'] || %w[gmake make].find { |c| system(c, '-v') }
+PKG_NAME    = 'amatch'
 PKG_VERSION = File.read('VERSION').chomp
-PKG_FILES   = FileList['**/*']
-PKG_FILES.exclude(/CVS/)
-PKG_FILES.exclude(/^pkg/)
-PKG_FILES.exclude(/^doc/)
+PKG_FILES   = FileList["**/*"].exclude(/^(pkg|coverage|doc)/)
+PKG_DOC_FILES = [ "ext/amatch.c" ].concat(Dir['lib/**/*.rb']) << 'doc-main.txt'
 
 task :default => :test
 
 desc "Run unit tests"
-task :test => :compile do
-  cd 'tests' do
-    ruby %{-I../ext runner.rb}
-  end
+task :test => :compile_ext do
+  sh %{testrb -Iext:lib tests/test_*.rb}
 end
 
 desc "Compiling library"
-task :compile do
+task :compile_ext do
   cd 'ext'  do
     ruby %{extconf.rb}
-    sh "make"
+    sh MAKE
   end
 end
 
@@ -40,72 +41,73 @@ end
 
 desc "Removing generated files"
 task :clean do
-  rm_rf 'doc'
-  cd 'ext'  do
+  cd 'ext' do
     ruby 'extconf.rb'
-    sh "make distclean" if File.exist?('Makefile')
+    sh "#{MAKE} distclean" if File.exist?('Makefile')
   end
 end
 
-Rake::RDocTask.new do |rd|
-  rd.main = 'Amatch'
-  rd.rdoc_files.include("ext/amatch.c")
-  rd.rdoc_dir = 'doc'
+desc "Build the documentation"
+task :doc do
+  sh "rdoc -m doc-main.txt -t '#{PKG_NAME} - Approximate Matching' #{PKG_DOC_FILES * ' '}"
 end
 
-spec = Gem::Specification.new do |s|
-  #### Basic information.
-
-  s.name = 'amatch'
-  s.version = PKG_VERSION
-  s.summary = "Approximate String Matching library"
-  s.description = <<EOF
+if defined? Gem
+  spec = Gem::Specification.new do |s|
+    s.name = 'amatch'
+    s.version = PKG_VERSION
+    s.summary = "Approximate String Matching library"
+    s.description = <<EOF
 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.
 EOF
 
-  #### Dependencies and requirements.
+    s.files = PKG_FILES
 
-  #s.add_dependency('log4r', '> 1.0.4')
-  #s.requirements << ""
+    s.extensions << "ext/extconf.rb"
 
-  s.files = PKG_FILES
+    s.require_path = 'ext'
 
-  #### C code extensions.
+    s.bindir = "bin"
+    s.executables = ["agrep.rb"]
+    s.default_executable = "agrep.rb"
 
-  s.extensions << "ext/extconf.rb"
+    s.has_rdoc = true
+    s.extra_rdoc_files.concat PKG_DOC_FILES
+    s.rdoc_options << '--main' << 'doc-main.txt' <<
+      '--title' << "#{PKG_NAME} - Approximate Matching"
+    s.test_files.concat Dir['tests/test_*.rb']
 
-  #### Load-time details: library and application (you will need one or both).
-
-  s.require_path = 'ext'                         # Use these for libraries.
-  s.autorequire = 'amatch'
-
-  s.bindir = "bin"                               # Use these for applications.
-  s.executables = ["agrep.rb"]
-  s.default_executable = "agrep.rb"
-
-  #### Documentation and testing.
-
-  s.has_rdoc = true
-  #s.extra_rdoc_files = FileList['ext/amatch.c']
-  s.rdoc_options <<
-    '--title' <<  'Amatch -- Approximate Matching' <<
-    '--main' << 'Amatch' <<
-    '--line-numbers'
-  s.test_files << 'tests/runner.rb'
-
-  #### Author and project details.
+    s.author = "Florian Frank"
+    s.email = "flori@ping.de"
+    s.homepage = "http://amatch.rubyforge.org"
+    s.rubyforge_project = "amatch"
+  end
 
-  s.author = "Florian Frank"
-  s.email = "flori@ping.de"
-  s.homepage = "http://amatch.rubyforge.org"
-  s.rubyforge_project = "amatch"
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar      = true
+    pkg.package_files += PKG_FILES
+  end
 end
 
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_tar      = true
-  pkg.package_files += PKG_FILES
+desc m = "Writing version information for #{PKG_VERSION}"
+task :version do
+  puts m
+  File.open(File.join('lib', 'amatch', 'version.rb'), 'w') do |v|
+    v.puts <<EOT
+module Amatch
+  # Amatch version
+  VERSION         = '#{PKG_VERSION}'
+  VERSION_ARRAY   = VERSION.split(/\\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
 end
+EOT
+  end
+end
+
 
-task :release => [ :clean, :package ]
+desc "Prepare a new release"
+task :release => [ :clean, :version, :package ]

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.2.4

data/bin/agrep.rb

@@ -1,8 +1,4 @@
 #! /usr/bin/env ruby
-# vim: set et sw=2 ts=2:
-#
-## $Id: agrep.rb,v 1.5 2006/09/26 15:59:48 flori Exp $
-#
 
 require 'amatch'
 require 'getoptlong'

data/doc-main.txt

@@ -0,0 +1,115 @@
+== 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.
+
+=== Author
+
+Florian Frank mailto:flori@ping.de
+
+=== License
+
+This is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License Version 2 as published by
+the Free Software Foundation: http://www.gnu.org/copyleft/gpl.html
+
+=== Download
+
+The latest version of <b>amatch</b> can be found at
+
+* http://rubyforge.org/frs/?group_id=390
+
+Online Documentation should be located at
+
+* http://amatch.rubyforge.org
+
+=== 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 = 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
+

data/ext/amatch.c

@@ -1,5 +1,7 @@
 #include "ruby.h"
 #include "pair.h"
+#include <ctype.h>
+#include "common.h"
 
 /*
  * Document-method: pattern
@@ -19,7 +21,8 @@
 
 
 static VALUE rb_mAmatch, rb_cLevenshtein, rb_cSellers, rb_cHamming,
-             rb_cPairDistance, rb_cLongestSubsequence, rb_cLongestSubstring;
+             rb_cPairDistance, rb_cLongestSubsequence, rb_cLongestSubstring,
+             rb_cJaro, rb_cJaroWinkler;
 
 static ID id_split, id_to_f;
 
@@ -62,10 +65,10 @@ static void type##_pattern_set(type *amatch, VALUE pattern)     \
 {                                                               \
     Check_Type(pattern, T_STRING);                              \
     free(amatch->pattern);                                      \
-    amatch->pattern_len = RSTRING(pattern)->len;                \
+    amatch->pattern_len = RSTRING_LEN(pattern);                 \
     amatch->pattern = ALLOC_N(char, amatch->pattern_len);       \
-    MEMCPY(amatch->pattern, RSTRING(pattern)->ptr, char,        \
-        RSTRING(pattern)->len);                                 \
+    MEMCPY(amatch->pattern, RSTRING_PTR(pattern), char,         \
+        RSTRING_LEN(pattern));                                  \
 }                                                               \
 static VALUE rb_##type##_pattern(VALUE self)                    \
 {                                                               \
@@ -80,16 +83,16 @@ static VALUE rb_##type##_pattern_set(VALUE self, VALUE pattern) \
 }
 
 #define DEF_ITERATE_STRINGS(type)                                   \
-static VALUE type##_iterate_strings(type *amatch, VALUE strings,     \
-    VALUE (*match_function) (type *amatch, VALUE strings))        \
+static VALUE type##_iterate_strings(type *amatch, VALUE strings,    \
+    VALUE (*match_function) (type *amatch, VALUE strings))          \
 {                                                                   \
     if (TYPE(strings) == T_STRING) {                                \
         return match_function(amatch, strings);                     \
     } else {                                                        \
         Check_Type(strings, T_ARRAY);                               \
         int i;                                                      \
-        VALUE result = rb_ary_new2(RARRAY(strings)->len);           \
-        for (i = 0; i < RARRAY(strings)->len; i++) {                \
+        VALUE result = rb_ary_new2(RARRAY_LEN(strings));            \
+        for (i = 0; i < RARRAY_LEN(strings); i++) {                 \
             VALUE string = rb_ary_entry(strings, i);                \
             if (TYPE(string) != T_STRING) {                         \
                 rb_raise(rb_eTypeError,                             \
@@ -130,17 +133,25 @@ VALUE function(VALUE self, VALUE value)                                 \
             obj = rb_funcall(obj, id_to_f, 0, 0);               \
         else                                                    \
             Check_Type(obj, T_FLOAT)
-#define FLOAT2C(obj) RFLOAT(obj)->value
+#define FLOAT2C(obj) (RFLOAT_VALUE(obj))
+
+#define CAST2BOOL(obj)                  \
+    if (obj == Qfalse || obj == Qnil)   \
+        obj = Qfalse;                   \
+    else                                \
+        obj = Qtrue;
+#define BOOL2C(obj) (obj == Qtrue)
+#define C2BOOL(obj) (obj ? Qtrue : Qfalse)
 
 #define OPTIMIZE_TIME                                   \
-    if (amatch->pattern_len < RSTRING(string)->len) {   \
+    if (amatch->pattern_len < RSTRING_LEN(string)) {    \
         a_ptr = amatch->pattern;                        \
         a_len = amatch->pattern_len;                    \
-        b_ptr = RSTRING(string)->ptr;                   \
-        b_len = RSTRING(string)->len;                   \
+        b_ptr = RSTRING_PTR(string);                    \
+        b_len = RSTRING_LEN(string);                    \
     } else {                                            \
-        a_ptr = RSTRING(string)->ptr;                   \
-        a_len = RSTRING(string)->len;                   \
+        a_ptr = RSTRING_PTR(string);                    \
+        a_len = RSTRING_LEN(string);                    \
         b_ptr = amatch->pattern;                        \
         b_len = amatch->pattern_len;                    \
     }
@@ -148,8 +159,8 @@ VALUE function(VALUE self, VALUE value)                                 \
 #define DONT_OPTIMIZE                                   \
         a_ptr = amatch->pattern;                        \
         a_len = amatch->pattern_len;                    \
-        b_ptr = RSTRING(string)->ptr;                   \
-        b_len = RSTRING(string)->len;                   \
+        b_ptr = RSTRING_PTR(string);                    \
+        b_len = RSTRING_LEN(string);                    \
 
 /*
  * C structures of the Amatch classes
@@ -192,6 +203,27 @@ typedef struct PairDistanceStruct {
 DEF_ALLOCATOR(PairDistance)
 DEF_PATTERN_ACCESSOR(PairDistance)
 
+typedef struct JaroStruct {
+    char *pattern;
+    int   pattern_len;
+    int   ignore_case;
+} Jaro;
+
+DEF_ALLOCATOR(Jaro)
+DEF_PATTERN_ACCESSOR(Jaro)
+DEF_ITERATE_STRINGS(Jaro)
+
+typedef struct JaroWinklerStruct {
+    char *pattern;
+    int   pattern_len;
+    int   ignore_case;
+    float scaling_factor;
+} JaroWinkler;
+
+DEF_ALLOCATOR(JaroWinkler)
+DEF_PATTERN_ACCESSOR(JaroWinkler)
+DEF_ITERATE_STRINGS(JaroWinkler)
+
 /*
  * Levenshtein edit distances are computed here:
  */
@@ -616,6 +648,123 @@ static VALUE LongestSubstring_similar(General *amatch, VALUE string)
     return rb_float_new(((double) result) / b_len);
 }
 
+/*
+ * Jaro computation
+ */
+
+#define COMPUTE_JARO                                                                \
+    l[0] = ALLOC_N(int, a_len);                                                     \
+    MEMZERO(l[0], int, a_len);                                                      \
+    l[1] = ALLOC_N(int, b_len);                                                     \
+    MEMZERO(l[1], int, b_len);                                                      \
+    max_dist = ((a_len > b_len ? a_len : b_len) / 2) - 1;                           \
+    m = 0;                                                                          \
+    for (i = 0; i < a_len; i++) {                                                   \
+        low = (i > max_dist ? i - max_dist : 0);                                     \
+        high = (i + max_dist < b_len ? i + max_dist : b_len);                       \
+        for (j = low; j <= high; j++) {                                              \
+            if (!l[1][j] && a_ptr[i] == b_ptr[j]) {                                 \
+                l[0][i] = 1;                                                        \
+                l[1][j] = 1;                                                        \
+                m++;                                                                \
+                break;                                                              \
+            }                                                                       \
+        }                                                                           \
+    }                                                                               \
+    if (m == 0) {                                                                   \
+        result = 0.0;                                                               \
+    } else {                                                                        \
+        k = t = 0;                                                                  \
+        for (i = 0; i < a_len; i++) {                                               \
+            if (l[0][i]) {                                                          \
+                for (j = k; j < b_len; j++) {                                       \
+                    if (l[1][j]) {                                                  \
+                        k = j + 1;                                                  \
+                        break;                                                      \
+                    }                                                               \
+                }                                                                   \
+                if (a_ptr[i] != b_ptr[j]) {                                         \
+                    t++;                                                            \
+                }                                                                   \
+            }                                                                       \
+        }                                                                           \
+        t = t / 2;                                                                  \
+        result = (((double)m)/a_len + ((double)m)/b_len + ((double)(m-t))/m)/3.0;   \
+    }
+
+#define LOWERCASE_STRINGS                                       \
+     char *ying = ALLOC_N(char, a_len);                         \
+     MEMCPY(ying, a_ptr, char, a_len);                          \
+     a_ptr = ying;                                              \
+     char *yang = ALLOC_N(char, b_len);                         \
+     MEMCPY(yang, b_ptr, char, b_len);                          \
+     b_ptr = yang;                                              \
+     for (i = 0; i < a_len; i++) {                              \
+         if (islower(a_ptr[i])) a_ptr[i] = toupper(a_ptr[i]);   \
+     }                                                          \
+     for (i = 0; i < b_len; i++) {                              \
+         if (islower(b_ptr[i])) b_ptr[i] = toupper(b_ptr[i]);   \
+     }
+
+#define FREE_STRINGS \
+     xfree(a_ptr);   \
+     xfree(b_ptr);
+
+static VALUE Jaro_match(Jaro *amatch, VALUE string)
+{
+    char *a_ptr, *b_ptr;
+    int a_len, b_len, max_dist, m, t, i, j, k, low, high;
+    int *l[2];
+    double result;
+
+    Check_Type(string, T_STRING);
+    OPTIMIZE_TIME
+    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);
+    if (amatch->ignore_case) {
+        LOWERCASE_STRINGS
+    }
+    COMPUTE_JARO
+    if (amatch->ignore_case) {
+        FREE_STRINGS
+    }
+    return rb_float_new(result);
+}
+
+/*
+ * Jaro-Winkler computation
+ */
+
+static VALUE JaroWinkler_match(JaroWinkler *amatch, VALUE string)
+{
+    char *a_ptr, *b_ptr;
+    int a_len, b_len, max_dist, m, t, i, j, k, low, high, n;
+    int *l[2];
+    double result;
+
+    Check_Type(string, T_STRING);
+    OPTIMIZE_TIME
+    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);
+    if (amatch->ignore_case) {
+        LOWERCASE_STRINGS
+    }
+    COMPUTE_JARO
+    n = 0;
+    for (i = 0; i < (a_len >= 4 ? 4 : a_len); i++) {
+        if (a_ptr[i] == b_ptr[i]) {
+            n++;
+        } else {
+            break;
+        }
+    }
+    result = result + n*amatch->scaling_factor*(1-result);
+    if (amatch->ignore_case) {
+        FREE_STRINGS
+    }
+    return rb_float_new(result);
+}
+
 /*
  * Ruby API
  */
@@ -951,8 +1100,8 @@ static VALUE rb_PairDistance_match(int argc, VALUE *argv, VALUE self)
     } else {
         Check_Type(strings, T_ARRAY);
         int i;
-        result = rb_ary_new2(RARRAY(strings)->len);
-        for (i = 0; i < RARRAY(strings)->len; i++) {
+        result = rb_ary_new2(RARRAY_LEN(strings));
+        for (i = 0; i < RARRAY_LEN(strings); i++) {
             VALUE string = rb_ary_entry(strings, i);
             if (TYPE(string) != T_STRING) {
                 rb_raise(rb_eTypeError,
@@ -1214,104 +1363,183 @@ 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
+ *
+ * This class computes the Jaro metric for two strings.
+ * The Jaro metric computes the similarity between 0 (no match)
+ * and 1 (exact match) by looking for matching and transposed characters.
+ */
+DEF_RB_FREE(Jaro, Jaro)
+
+/*
+ * Document-method: ignore_case
+ *
+ * call-seq: ignore_case -> true/false
+ *
+ * Returns whether case is ignored when computing matching characters.
+ */
+DEF_RB_READER(Jaro, rb_Jaro_ignore_case, ignore_case, C2BOOL)
+
+/*
+ * Document-method: ignore_case=
+ *
+ * call-seq: ignore_case=(true/false)
+ *
+ * Sets whether case is ignored when computing matching characters.
+ */
+DEF_RB_WRITER(Jaro, rb_Jaro_ignore_case_set, ignore_case,
+    int, CAST2BOOL, BOOL2C, != Qundef)
+
+/*
+ * call-seq: new(pattern)
+ *
+ * Creates a new Amatch::Jaro instance from <code>pattern</code>.
+ */
+static VALUE rb_Jaro_initialize(VALUE self, VALUE pattern)
+{
+    GET_STRUCT(Jaro)
+    Jaro_pattern_set(amatch, pattern);
+    amatch->ignore_case = 1;
+    return self;
+}
+
+DEF_CONSTRUCTOR(Jaro, Jaro)
 
 /*
- * = amatch - Approximate Matching Extension for Ruby
+ * call-seq: match(strings) -> results
  *
- * == Description
+ * Uses this Amatch::Jaro instance to match
+ * Jaro#pattern against <code>strings</code>, that is compute the
+ * jaro metric with the strings. <code>strings</code> has to be
+ * either a String or an Array of Strings. The returned <code>results</code>
+ * are either a Float or an Array of Floats respectively.
+ */
+static VALUE rb_Jaro_match(VALUE self, VALUE strings)
+{
+    GET_STRUCT(Jaro)
+    return Jaro_iterate_strings(amatch, strings, Jaro_match);
+}
+
+/*
+ * call-seq: jaro_similar(strings) -> results
  *
- * 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, and the pair distance metric.
+ * If called on a String, this string is used as a
+ * Amatch::Jaro#pattern to match against <code>strings</code>. It
+ * returns a Jaro 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>
+ * are either a Float or an Array of Floats respectively.
+ */
+static VALUE rb_str_jaro_similar(VALUE self, VALUE strings)
+{
+    VALUE amatch = rb_Jaro_new(rb_cJaro, self);
+    return rb_Jaro_match(amatch, strings);
+}
+
+/*
+ * Document-class: Amatch::JaroWinkler
  *
- * == Author
+ * This class computes the Jaro-Winkler metric for two strings.
+ * The Jaro-Winkler metric computes the similarity between 0 (no match)
+ * and 1 (exact match) by looking for matching and transposed characters.
  *
- * Florian Frank mailto:flori@ping.de
+ * It is a variant of the Jaro metric, with additional weighting towards
+ * common prefixes.
+ */
+DEF_RB_FREE(JaroWinkler, JaroWinkler)
+
+/*
+ * Document-method: ignore_case
  *
- * == License
+ * call-seq: ignore_case -> true/false
  *
- * This is free software; you can redistribute it and/or modify it under
- * the terms of the GNU General Public License Version 2 as published by
- * the Free Software Foundation: http://www.gnu.org/copyleft/gpl.html
+ * Returns whether case is ignored when computing matching characters.
+ * Default is true.
+ */
+DEF_RB_READER(JaroWinkler, rb_JaroWinkler_ignore_case, ignore_case, C2BOOL)
+
+/*
+ * Document-method: scaling_factor
  *
- * == Download
+ * call-seq: scaling_factor -> weight
  *
- * The latest version of <b>amatch</b> can be found at
+ * The scaling factor is how much weight to give common prefixes.
+ * Default is 0.1.
+ */
+DEF_RB_READER(JaroWinkler, rb_JaroWinkler_scaling_factor, scaling_factor, rb_float_new)
+
+/*
+ * Document-method: ignore_case=
  *
- * * http://rubyforge.org/frs/?group_id=390
+ * call-seq: ignore_case=(true/false)
  *
- * Online Documentation should be located at
+ * Sets whether case is ignored when computing matching characters.
+ */
+DEF_RB_WRITER(JaroWinkler, rb_JaroWinkler_ignore_case_set, ignore_case,
+    int, CAST2BOOL, BOOL2C, != Qundef)
+
+/*
+ * Document-method: scaling_factor=
+ *
+ * call-seq: scaling_factor=(weight)
+ *
+ * Sets the weight to give common prefixes.
+ */
+DEF_RB_WRITER(JaroWinkler, rb_JaroWinkler_scaling_factor_set, scaling_factor,
+    double, CAST2FLOAT, FLOAT2C, >= 0)
+
+/*
+ * call-seq: new(pattern)
  *
- * * http://amatch.rubyforge.org
+ * Creates a new Amatch::JaroWinkler instance from <code>pattern</code>.
+ */
+static VALUE rb_JaroWinkler_initialize(VALUE self, VALUE pattern)
+{
+    GET_STRUCT(JaroWinkler)
+    JaroWinkler_pattern_set(amatch, pattern);
+    amatch->ignore_case = 1;
+    amatch->scaling_factor = 0.1;
+    return self;
+}
+
+DEF_CONSTRUCTOR(JaroWinkler, JaroWinkler)
+
+/*
+ * call-seq: match(strings) -> results
  *
- * == 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 = 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
+ * Uses this Amatch::Jaro instance to match
+ * Jaro#pattern against <code>strings</code>, that is compute the
+ * jaro metric with the strings. <code>strings</code> has to be
+ * either a String or an Array of Strings. The returned <code>results</code>
+ * are either a Float or an Array of Floats respectively.
+ */
+static VALUE rb_JaroWinkler_match(VALUE self, VALUE strings)
+{
+    GET_STRUCT(JaroWinkler)
+    return JaroWinkler_iterate_strings(amatch, strings, JaroWinkler_match);
+}
+
+/*
+ * call-seq: jarowinkler_similar(strings) -> results
  *
+ * If called on a String, this string is used as a
+ * Amatch::JaroWinkler#pattern to match against <code>strings</code>. It
+ * returns a Jaro-Winkler 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>
+ * are either a Float or an Array of Floats respectively.
  */
+static VALUE rb_str_jarowinkler_similar(VALUE self, VALUE strings)
+{
+    VALUE amatch = rb_JaroWinkler_new(rb_cJaro, self);
+    return rb_JaroWinkler_match(amatch, strings);
+}
 
 void Init_amatch()
 {
+    rb_require("amatch/version");
     rb_mAmatch = rb_define_module("Amatch");
 
     /* Levenshtein */
@@ -1382,7 +1610,32 @@ void Init_amatch()
     rb_define_method(rb_cLongestSubstring, "similar", rb_LongestSubstring_similar, 1);
     rb_define_method(rb_cString, "longest_substring_similar", rb_str_longest_substring_similar, 1);
 
+    /* Jaro */
+    rb_cJaro = rb_define_class_under(rb_mAmatch, "Jaro", rb_cObject);
+    rb_define_alloc_func(rb_cJaro, rb_Jaro_s_allocate);
+    rb_define_method(rb_cJaro, "initialize", rb_Jaro_initialize, 1);
+    rb_define_method(rb_cJaro, "pattern", rb_Jaro_pattern, 0);
+    rb_define_method(rb_cJaro, "pattern=", rb_Jaro_pattern_set, 1);
+    rb_define_method(rb_cJaro, "ignore_case", rb_Jaro_ignore_case, 0);
+    rb_define_method(rb_cJaro, "ignore_case=", rb_Jaro_ignore_case_set, 1);
+    rb_define_method(rb_cJaro, "match", rb_Jaro_match, 1);
+    rb_define_alias(rb_cJaro, "similar", "match");
+    rb_define_method(rb_cString, "jaro_similar", rb_str_jaro_similar, 1);
+
+    /* Jaro-Winkler */
+    rb_cJaroWinkler = rb_define_class_under(rb_mAmatch, "JaroWinkler", rb_cObject);
+    rb_define_alloc_func(rb_cJaroWinkler, rb_JaroWinkler_s_allocate);
+    rb_define_method(rb_cJaroWinkler, "initialize", rb_JaroWinkler_initialize, 1);
+    rb_define_method(rb_cJaroWinkler, "pattern", rb_JaroWinkler_pattern, 0);
+    rb_define_method(rb_cJaroWinkler, "pattern=", rb_JaroWinkler_pattern_set, 1);
+    rb_define_method(rb_cJaroWinkler, "ignore_case", rb_JaroWinkler_ignore_case, 0);
+    rb_define_method(rb_cJaroWinkler, "ignore_case=", rb_JaroWinkler_ignore_case_set, 1);
+    rb_define_method(rb_cJaroWinkler, "scaling_factor", rb_JaroWinkler_scaling_factor, 0);
+    rb_define_method(rb_cJaroWinkler, "scaling_factor=", rb_JaroWinkler_scaling_factor_set, 1);
+    rb_define_method(rb_cJaroWinkler, "match", rb_JaroWinkler_match, 1);
+    rb_define_alias(rb_cJaroWinkler, "similar", "match");
+    rb_define_method(rb_cString, "jarowinkler_similar", rb_str_jarowinkler_similar, 1);
+
     id_split = rb_intern("split");
     id_to_f = rb_intern("to_f");
 }
-    /* vim: set et cin sw=4 ts=4: */