jaro_winkler 1.3.7 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7687918cbfcaa8ffb589f1d1383ac2e6611e235f
-  data.tar.gz: e8129522a42193023a77593dddfe3917eafe3f68
+  metadata.gz: fe11a8c8be8cadef3f1f14f847c40a0a8e41268f
+  data.tar.gz: f509aaa81627917a4cf1017884f43b60dcd5483b
 SHA512:
-  metadata.gz: be7befc2a7e5c5a2866ba7e4995bf99a0f9d75bfab3e01c806a1d39b10b0a27975f795f2330248e96e5673a8ce81d0ef01fa12a6d18f3f2cf73ff9de28764a60
-  data.tar.gz: 3183fb3c534e1c1820ee16cd6a81bfcd35899ffc586e5ac064f5e4deace965d5507b83ca1d4a1fe3d8d30cc894da72eb998f1119ec3223a61c50c072d7e2029d
+  metadata.gz: 88fca6ab51c8a830de64e23b96f7efaaeeac01cd71735dd3820fc9e84e5de0027872014a8aef0278658d45455a7719a81601604929d17228fd6e8b6cb8fba919
+  data.tar.gz: ab7ee1020506ba6693e2b9878afddcb4a39bf7fb0be89b3958cfc5571f051b8295898cf050d517aa2c1951b23093517ce2d82d8d9c5544e816a4ac9e34c5bc6c

data/ext/jaro_winkler/extconf.rb

@@ -1,11 +1,11 @@
 unless RUBY_PLATFORM == 'java'
-  require "mkmf"
+  require 'mkmf'
   $CFLAGS << ' -std=c99 '
-  create_makefile("jaro_winkler/jaro_winkler")
+  create_makefile('jaro_winkler/jaro_winkler_ext')
 else
-  dummy_makefile = open("Makefile", "wb")
+  dummy_makefile = open('Makefile', 'wb')
   dummy_makefile.puts '.PHONY: install'
   dummy_makefile.puts 'install:'
-  dummy_makefile.puts "\t" + '@echo "Extensions not installed, falling back to pure Ruby version."'
+  dummy_makefile.puts "\t" + '@echo "C extension is not installed, fall back to pure Ruby version instead."'
   dummy_makefile.close
 end

data/ext/jaro_winkler/jaro.c

@@ -6,19 +6,47 @@
 #include <stdlib.h>
 #include <ctype.h>
 
-double jaro_winkler_distance(char* short_str, int short_str_len, char* long_str, int long_str_len, LibJaroOption *opt){
+#define SWAP(x, y) do{ __typeof__(x) SWAP = x; x = y; y = SWAP; }while(0)
+
+double jaro_distance_from_codes(unsigned long long *codes1, int len1, unsigned long long *codes2, int len2, LibJaroOption *opt);
+double jaro_winkler_distance_from_codes(unsigned long long *codes1, int len1, unsigned long long *codes2, int len2, LibJaroOption *opt);
+
+double jaro_distance(char* short_str, int short_str_len, char* long_str, int long_str_len, LibJaroOption *opt){
   if(!short_str_len || !long_str_len) return 0.0;
 
-  if(short_str_len > long_str_len){
-    SWAP(short_str, long_str);
-    SWAP(short_str_len, long_str_len);
-  }
+  unsigned long long *short_codes, *long_codes;
+  int short_codes_len, long_codes_len;
+  string_to_codes(short_str, short_str_len, &short_codes, &short_codes_len);
+  string_to_codes(long_str, long_str_len, &long_codes, &long_codes_len);
+
+  double ret = jaro_distance_from_codes(short_codes, short_codes_len, long_codes, long_codes_len, opt);
+
+  free(short_codes); free(long_codes);
+  return ret;
+}
+
+double jaro_winkler_distance(char* short_str, int short_str_len, char* long_str, int long_str_len, LibJaroOption *opt){
+  if(!short_str_len || !long_str_len) return 0.0;
 
   unsigned long long *short_codes, *long_codes;
   int short_codes_len, long_codes_len;
   string_to_codes(short_str, short_str_len, &short_codes, &short_codes_len);
   string_to_codes(long_str, long_str_len, &long_codes, &long_codes_len);
 
+  double ret = jaro_winkler_distance_from_codes(short_codes, short_codes_len, long_codes, long_codes_len, opt);
+
+  free(short_codes); free(long_codes);
+  return ret;
+}
+
+double jaro_distance_from_codes(unsigned long long* short_codes, int short_codes_len, unsigned long long* long_codes, int long_codes_len, LibJaroOption *opt){
+  if(!short_codes_len || !long_codes_len) return 0.0;
+
+  if(short_codes_len > long_codes_len){
+    SWAP(short_codes, long_codes);
+    SWAP(short_codes_len, long_codes_len);
+  }
+
   if(opt->ignore_case){
     for(int i = 0; i < short_codes_len; i++) short_codes[i] = tolower(short_codes[i]);
     for(int i = 0; i < long_codes_len; i++) long_codes[i] = tolower(long_codes[i]);
@@ -27,10 +55,10 @@ double jaro_winkler_distance(char* short_str, int short_str_len, char* long_str,
   int window_size = long_codes_len/2 - 1;
   if(window_size < 0) window_size = 0;
 
-  char short_codes_flag[short_str_len];
-  char long_codes_flag[long_str_len];
-  memset(short_codes_flag, 0, short_str_len);
-  memset(long_codes_flag, 0, long_str_len);
+  char short_codes_flag[short_codes_len];
+  char long_codes_flag[long_codes_len];
+  memset(short_codes_flag, 0, short_codes_len);
+  memset(long_codes_flag, 0, long_codes_len);
 
   // count number of matching characters
   int match_count = 0;
@@ -46,10 +74,8 @@ double jaro_winkler_distance(char* short_str, int short_str_len, char* long_str,
       }
     }
   }
-  if(!match_count){
-    free(short_codes); free(long_codes);
-    return 0.0;
-  }
+
+  if(!match_count) return 0.0;
 
   // count number of transpositions
   int transposition_count = 0, j = 0, k = 0;
@@ -77,27 +103,20 @@ double jaro_winkler_distance(char* short_str, int short_str_len, char* long_str,
               break;
             }
 
-  // jaro distance
-  double jaro_distance;
   double m = (double)match_count;
   double t = (double)(transposition_count/2);
   if(opt->adj_table) m = similar_count/10.0 + m;
-  jaro_distance = (m/short_codes_len + m/long_codes_len + (m-t)/m) / 3;
+  return (m/short_codes_len + m/long_codes_len + (m-t)/m) / 3;
+}
 
-  // jaro winkler distance
-  if(!opt){
-    static LibJaroOption default_opt = {.weight = DEFAULT_WEIGHT, .threshold = DEFAULT_THRESHOLD};
-    opt = &default_opt;
-  }
-  if(jaro_distance < opt->threshold){
-    free(short_codes); free(long_codes);
-    return jaro_distance;
-  }
+double jaro_winkler_distance_from_codes(unsigned long long* short_codes, int short_codes_len, unsigned long long* long_codes, int long_codes_len, LibJaroOption *opt){
+  double jaro_distance = jaro_distance_from_codes(short_codes, short_codes_len, long_codes, long_codes_len, opt);
+
+  if(jaro_distance < opt->threshold) return jaro_distance;
   else{
     int prefix = 0;
     int max_4 = short_codes_len > 4 ? 4 : short_codes_len;
     for(prefix = 0; prefix < max_4 && short_codes[prefix] == long_codes[prefix]; prefix++);
-    free(short_codes); free(long_codes);
     return jaro_distance + prefix*opt->weight*(1-jaro_distance);
   }
 }

data/ext/jaro_winkler/jaro.h

@@ -1,7 +1,6 @@
 #ifndef LIBJARO_JARO_H
 #define LIBJARO_JARO_H
 
-#define SWAP(x, y) do{ __typeof__(x) SWAP = x; x = y; y = SWAP; }while(0)
 #define DEFAULT_WEIGHT 0.1
 #define DEFAULT_THRESHOLD 0.7
 
@@ -10,6 +9,9 @@ typedef struct LibJaroOption{
   char ignore_case, adj_table;
 } LibJaroOption;
 
+
+static const LibJaroOption DEFAULT_OPT = {.weight = DEFAULT_WEIGHT, .threshold = DEFAULT_THRESHOLD, .ignore_case = 0, .adj_table = 0};
+double jaro_distance(char *str1, int len1, char *str2, int len2, LibJaroOption *opt);
 double jaro_winkler_distance(char *str1, int len1, char *str2, int len2, LibJaroOption *opt);
 
 #endif

data/ext/jaro_winkler/jaro_winkler.c

@@ -1,28 +1,45 @@
 #include "ruby.h"
 #include "jaro.h"
 
-VALUE rb_mJaroWinkler;
-VALUE distance(int argc, VALUE *argv, VALUE self);
+VALUE rb_mJaroWinkler,
+      rb_eError,
+      rb_eInvalidWeightError;
 
-void Init_jaro_winkler(void){
+VALUE rb_jaro_winkler_distance(int argc, VALUE *argv, VALUE self);
+VALUE rb_jaro_distance(int argc, VALUE *argv, VALUE self);
+VALUE distance(int argc, VALUE *argv, VALUE self, double (*distance_fn)(char *str1, int len1, char *str2, int len2, LibJaroOption *opt));
+
+void Init_jaro_winkler_ext(void){
   rb_mJaroWinkler = rb_define_module("JaroWinkler");
-  rb_define_module_function(rb_mJaroWinkler, "c_distance", distance, -1);
+  rb_eError = rb_define_class_under(rb_mJaroWinkler, "Error", rb_eRuntimeError);
+  rb_eInvalidWeightError = rb_define_class_under(rb_mJaroWinkler, "InvalidWeightError", rb_eError);
+  rb_define_module_function(rb_mJaroWinkler, "distance", rb_jaro_winkler_distance, -1);
+  rb_define_module_function(rb_mJaroWinkler, "jaro_distance", rb_jaro_distance, -1);
 }
 
-VALUE distance(int argc, VALUE *argv, VALUE self){
+
+VALUE distance(int argc, VALUE *argv, VALUE self, double (*distance_fn)(char *str1, int len1, char *str2, int len2, LibJaroOption *opt)){
   VALUE s1, s2, opt;
   rb_scan_args(argc, argv, "2:", &s1, &s2, &opt);
-  LibJaroOption c_opt = {.weight = DEFAULT_WEIGHT, .threshold = DEFAULT_THRESHOLD, .ignore_case = 0, .adj_table = 0};
+  LibJaroOption c_opt = DEFAULT_OPT;
   if(TYPE(opt) == T_HASH){
     VALUE weight = rb_hash_aref(opt, ID2SYM(rb_intern("weight"))),
           threshold = rb_hash_aref(opt, ID2SYM(rb_intern("threshold"))),
           ignore_case = rb_hash_aref(opt, ID2SYM(rb_intern("ignore_case"))),
           adj_table = rb_hash_aref(opt, ID2SYM(rb_intern("adj_table")));
     if(!NIL_P(weight)) c_opt.weight = NUM2DBL(weight);
-    if(c_opt.weight > 0.25) rb_raise(rb_eRuntimeError, "Scaling factor should not exceed 0.25, otherwise the distance can become larger than 1.");
+    if(c_opt.weight > 0.25) rb_raise(rb_eInvalidWeightError, "Scaling factor should not exceed 0.25, otherwise the distance can become larger than 1.");
     if(!NIL_P(threshold)) c_opt.threshold = NUM2DBL(threshold);
     if(!NIL_P(ignore_case)) c_opt.ignore_case = (TYPE(ignore_case) == T_FALSE || NIL_P(ignore_case)) ? 0 : 1;
     if(!NIL_P(adj_table)) c_opt.adj_table = (TYPE(adj_table) == T_FALSE || NIL_P(adj_table)) ? 0 : 1;
   }
-  return rb_float_new(jaro_winkler_distance(StringValuePtr(s1), RSTRING_LEN(s1), StringValuePtr(s2), RSTRING_LEN(s2), &c_opt));
+  return rb_float_new((*distance_fn)(StringValuePtr(s1), RSTRING_LEN(s1), StringValuePtr(s2), RSTRING_LEN(s2), &c_opt));
+}
+
+VALUE rb_jaro_distance(int argc, VALUE *argv, VALUE self){
+  return distance(argc, argv, self, jaro_distance);
+}
+
+VALUE rb_jaro_winkler_distance(int argc, VALUE *argv, VALUE self){
+  return distance(argc, argv, self, jaro_winkler_distance);
 }

data/lib/jaro_winkler.rb

@@ -1,76 +1,9 @@
-require 'jaro_winkler/fallback'
-require 'jaro_winkler/adjusting_table'
-require 'jaro_winkler/jaro_winkler.so' unless JaroWinkler.fallback?
-module JaroWinkler
-  module_function
-  def jaro_distance s1, s2, options = {}
-    options[:adj_table]
-    length1, length2 = s1.length, s2.length
-    # Guarantee the length order
-    if s1.length > s2.length
-      s1, s2 = s2, s1
-      length1, length2 = length2, length1
-    end
-    window_size    = (length2 / 2) - 1
-    window_size    = 0 if window_size < 0
-    matches        = 0.0
-    sim_matches    = 0.0
-    transpositions = 0
-    previous_index = -1
-    max_index      = length2 - 1
-    s1.chars.each_with_index do |c1, i|
-      left      = i - window_size
-      right     = i + window_size
-      left      = 0         if left  < 0
-      right     = max_index if right > max_index
-      matched   = false
-      sim_matched = false
-      found     = false
-      s2[left..right].chars.each_with_index do |c2, j|
-        if c1 == c2
-          matched  = true
-          s2_index = left + j
-          if !found && s2_index > previous_index
-            previous_index = s2_index
-            found          = true
-          end
-        elsif options[:adj_table] && DEFAULT_ADJ_TABLE[c1][c2]
-          sim_matched = true
-        end
-      end
-      if matched
-        matches += 1
-        transpositions += 1 unless found
-      elsif sim_matched # not matched but similarly matched
-        sim_matches += 3
-      end
-    end
-    # Don't divide transpositions by 2 since it's been counted directly by above code.
-    similarity = matches
-    similarity += sim_matches / 10 if options[:adj_table]
-    matches == 0 ? 0 : (similarity / length1 + similarity / length2 + (matches - transpositions) / matches) / 3.0
-  end
+require 'jaro_winkler/version'
 
-  def r_distance s1, s2, options = {}
-    options = {weight: 0.1, threshold: 0.7, ignore_case: false, adj_table: false}.merge options
-    weight, threshold, ignore_case = options[:weight], options[:threshold], options[:ignore_case]
-    raise 'Scaling factor should not exceed 0.25, otherwise the distance can become larger than 1' if weight > 0.25
-    s1, s2     = s1.upcase, s2.upcase if ignore_case
-    distance   = jaro_distance(s1, s2, options)
-    prefix     = 0
-    max_length = [4, s1.length, s2.length].min
-    s1[0, max_length].chars.each_with_index do |c1, i|
-      c1 == s2[i] ? prefix += 1 : break
-    end
-    distance < threshold ? distance : distance + ((prefix * weight) * (1 - distance))
-  end
-
-  if JaroWinkler.fallback?
-    alias :distance :r_distance
-    alias :c_distance :r_distance
-    module_function :distance, :c_distance
-  else
-    alias :distance :c_distance
-    module_function :distance
-  end
-end
+case RUBY_PLATFORM
+when 'java'
+  require 'jaro_winkler/jaro_winkler_pure'
+else
+  require 'jaro_winkler/jaro_winkler_ext'
+end
+  

data/lib/jaro_winkler/jaro_winkler_pure.rb

@@ -0,0 +1,125 @@
+require 'jaro_winkler/adjusting_table'
+module JaroWinkler
+  class Error < RuntimeError; end
+  class InvalidWeightError < Error; end
+
+  DEFAULT_WEIGHT = 0.1
+  DEFAULT_THRESHOLD = 0.7
+  DEFAULT_OPTIONS = {
+    jaro: {adj_table: false, ignore_case: false},
+    jaro_winkler: {weight: DEFAULT_WEIGHT, threshold: DEFAULT_THRESHOLD}
+  }
+
+  module_function
+
+  def distance str1, str2, options={}
+    _distance str1.codepoints.to_a, str2.codepoints.to_a, options
+  end
+
+  def jaro_distance str1, str2, options={}
+    _jaro_distance str1.codepoints.to_a, str2.codepoints.to_a, options
+  end
+
+  def _distance codes1, codes2, options={}
+    options = DEFAULT_OPTIONS[:jaro_winkler].merge options
+    raise InvalidWeightError if options[:weight] > 0.25
+    jaro_distance = _jaro_distance(codes1, codes2, options);
+
+    if jaro_distance < options[:threshold]
+      jaro_distance
+    else
+      codes1, codes2 = codes2, codes1 if codes1.length > codes2.length
+      len1, len2 = codes1.length, codes2.length
+      max_4 = len1 > 4 ? 4 : len1
+      prefix = 0
+      while prefix < max_4 && codes1[prefix] == codes2[prefix]
+        prefix += 1
+      end
+      jaro_distance + prefix * options[:weight] * (1 - jaro_distance)
+    end
+  end
+
+  def _jaro_distance codes1, codes2, options={}
+    options = DEFAULT_OPTIONS[:jaro].merge options
+
+    codes1, codes2 = codes2, codes1 if codes1.length > codes2.length
+    len1, len2 = codes1.length, codes2.length
+    return 0.0 if len1 == 0 || len2 == 0
+
+    if options[:ignore_case]
+      codes1.map!{ |c| c >= 97 && c <= 122 ? c -= 32 : c }
+      codes2.map!{ |c| c >= 97 && c <= 122 ? c -= 32 : c }
+    end
+
+    window = len2/2 - 1
+    window = 0 if(window < 0)
+    flags1, flags2 = 0, 0
+
+    # // count number of matching characters
+    match_count = 0;
+    i = 0
+    while i < len1
+      left = (i >= window) ? i - window : 0
+      right = (i + window <= len2 - 1) ? (i + window) : (len2 - 1)
+      right = len2 - 1 if right > len2 - 1
+      j = left
+      while j <= right
+        if flags2[j] == 0 && codes1[i] == codes2[j]
+          flags1 |= (1 << i)
+          flags2 |= (1 << j)
+          match_count += 1
+          break
+        end
+        j +=1
+      end
+      i += 1
+    end
+
+    return 0.0 if match_count == 0
+
+    # // count number of transpositions
+    transposition_count = j = k = 0
+    i = 0
+    while i < len1
+      if flags1[i] == 1
+        j = k
+        while j < len2
+          if flags2[j] == 1
+            k = j + 1;
+            break;
+          end
+          j += 1
+        end
+        transposition_count += 1 if codes1[i] != codes2[j]
+      end
+      i += 1
+    end
+
+    # // count similarities in nonmatched characters
+    similar_count = 0
+    if options[:adj_table] && len1 > match_count
+      i = 0
+      while i < len1
+        if flags1[i] == 0
+          j = 0
+          while j < len2
+            if flags2[j] == 0
+              if DEFAULT_ADJ_TABLE[codes1[i].chr(Encoding::UTF_8)][codes2[j].chr(Encoding::UTF_8)]
+                similar_count += 3
+                break
+              end
+            end
+            j += 1
+          end
+        end
+        i += 1
+      end
+    end
+
+    m = match_count.to_f
+    t = transposition_count/2
+    m = similar_count/10.0 + m if options[:adj_table]
+    (m/len1 + m/len2 + (m-t)/m) / 3
+  end
+
+end

data/lib/jaro_winkler/version.rb

@@ -1,3 +1,3 @@
 module JaroWinkler
-  VERSION = "1.3.7"
+  VERSION = '1.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jaro_winkler
 version: !ruby/object:Gem::Version
-  version: 1.3.7
+  version: 1.4.0
 platform: ruby
 authors:
 - Jian Weihang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-28 00:00:00.000000000 Z
+date: 2015-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,49 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: fuzzy-string-match
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: hotwater
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: amatch
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -128,7 +86,7 @@ files:
 - ext/jaro_winkler/murmur_hash2.c
 - lib/jaro_winkler.rb
 - lib/jaro_winkler/adjusting_table.rb
-- lib/jaro_winkler/fallback.rb
+- lib/jaro_winkler/jaro_winkler_pure.rb
 - lib/jaro_winkler/version.rb
 homepage: https://github.com/tonytonyjan/jaro_winkler
 licenses:
@@ -150,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Ruby & C implementation of Jaro-Winkler distance algorithm which both support

data/lib/jaro_winkler/fallback.rb

@@ -1,6 +0,0 @@
-module JaroWinkler
-  module_function
-  def fallback?
-    RUBY_PLATFORM == 'java'
-  end
-end