JaroWinkler and Levenshtein

Author: tibo

string-similarity/src/info/debatty/stringsimilarity/JaroWinkler.java

@@ -0,0 +1,117 @@
+package info.debatty.stringsimilarity;
+
+import java.util.Arrays;
+
+/**
+ *
+ * @author tibo
+ */
+public class JaroWinkler {
+    
+    /**
+     * The Jaro–Winkler distance is in fact a measure of similarity between two
+     * strings: 0 means no similarity and 1 is an exact match.
+     * http://en.wikipedia.org/wiki/Jaro-Winkler_distance
+     * 
+     * @param s0
+     * @param s1
+     * @return 
+     */
+    public static double Similarity(String s0, String s1) {
+        JaroWinkler jw = new JaroWinkler();
+        return jw.sim(s0, s1);
+    }
+
+    
+    private float threshold = 0.7f;
+
+    private int[] matches(String s1, String s2) {
+        String max, min;
+        if (s1.length() > s2.length()) {
+            max = s1;
+            min = s2;
+        } else {
+            max = s2;
+            min = s1;
+        }
+        int range = Math.max(max.length() / 2 - 1, 0);
+        int[] matchIndexes = new int[min.length()];
+        Arrays.fill(matchIndexes, -1);
+        boolean[] matchFlags = new boolean[max.length()];
+        int matches = 0;
+        for (int mi = 0; mi < min.length(); mi++) {
+            char c1 = min.charAt(mi);
+            for (int xi = Math.max(mi - range, 0),
+                    xn = Math.min(mi + range + 1, max.length()); xi < xn; xi++) {
+                if (!matchFlags[xi] && c1 == max.charAt(xi)) {
+                    matchIndexes[mi] = xi;
+                    matchFlags[xi] = true;
+                    matches++;
+                    break;
+                }
+            }
+        }
+        char[] ms1 = new char[matches];
+        char[] ms2 = new char[matches];
+        for (int i = 0, si = 0; i < min.length(); i++) {
+            if (matchIndexes[i] != -1) {
+                ms1[si] = min.charAt(i);
+                si++;
+            }
+        }
+        for (int i = 0, si = 0; i < max.length(); i++) {
+            if (matchFlags[i]) {
+                ms2[si] = max.charAt(i);
+                si++;
+            }
+        }
+        int transpositions = 0;
+        for (int mi = 0; mi < ms1.length; mi++) {
+            if (ms1[mi] != ms2[mi]) {
+                transpositions++;
+            }
+        }
+        int prefix = 0;
+        for (int mi = 0; mi < min.length(); mi++) {
+            if (s1.charAt(mi) == s2.charAt(mi)) {
+                prefix++;
+            } else {
+                break;
+            }
+        }
+        return new int[]{matches, transpositions / 2, prefix, max.length()};
+    }
+
+    public float sim(String s1, String s2) {
+        int[] mtp = matches(s1, s2);
+        float m = mtp[0];
+        if (m == 0) {
+            return 0f;
+        }
+        float j = ((m / s1.length() + m / s2.length() + (m - mtp[1]) / m)) / 3;
+        float jw = j < getThreshold() ? j : j + Math.min(0.1f, 1f / mtp[3]) * mtp[2]
+                * (1 - j);
+        return jw;
+    }
+
+    /**
+     * Sets the threshold used to determine when Winkler bonus should be used.
+     * Set to a negative value to get the Jaro distance.
+     *
+     * @param threshold the new value of the threshold
+     */
+    public void setThreshold(float threshold) {
+        this.threshold = threshold;
+    }
+
+    /**
+     * Returns the current value of the threshold used for adding the Winkler
+     * bonus. The default value is 0.7.
+     *
+     * @return the current value of the threshold
+     */
+    public float getThreshold() {
+        return threshold;
+    }
+
+}

string-similarity/src/info/debatty/stringsimilarity/Levenshtein.java

@@ -0,0 +1,74 @@
+package info.debatty.stringsimilarity;
+
+/**
+ *
+ * @author tibo
+ */
+public class Levenshtein {
+
+    /**
+     * The Levenshtein distance, or edit distance, between two words is the 
+     * minimum number of single-character edits (i.e. insertions, deletions or 
+     * substitutions) required to change one word into the other. 
+     * 
+     * http://en.wikipedia.org/wiki/Levenshtein_distance
+     * 
+     * It is always at least the difference of the sizes of the two strings.
+     * It is at most the length of the longer string.
+     * It is zero if and only if the strings are equal.
+     * If the strings are the same size, the Hamming distance is an upper bound 
+     * on the Levenshtein distance.
+     * The Levenshtein distance between two strings is no greater than the sum 
+     * of their Levenshtein distances from a third string (triangle inequality).
+     * 
+     * @param s0
+     * @param s1
+     * @return 
+     */
+    public static int Distance(String s0, String s1) {
+        int len0 = s0.length() + 1;
+        int len1 = s1.length() + 1;
+
+        // the array of distances
+        int[] cost = new int[len0];
+        int[] newcost = new int[len0];
+
+        // initial cost of skipping prefix in String s0
+        for (int i = 0; i < len0; i++) {
+            cost[i] = i;
+        }
+
+	// dynamicaly computing the array of distances
+        // transformation cost for each letter in s1
+        for (int j = 1; j < len1; j++) {
+
+            // initial cost of skipping prefix in String s1
+            newcost[0] = j - 1;
+
+            // transformation cost for each letter in s0
+            for (int i = 1; i < len0; i++) {
+
+                // matching current letters in both strings
+                int match = (s0.charAt(i - 1) == s1.charAt(j - 1)) ? 0 : 1;
+
+                // computing cost for each transformation
+                int cost_replace = cost[i - 1] + match;
+                int cost_insert = cost[i] + 1;
+                int cost_delete = newcost[i - 1] + 1;
+
+                // keep minimum cost
+                newcost[i] = Math.min(
+                        Math.min(cost_insert, cost_delete),
+                        cost_replace);
+            }
+
+            // swap cost/newcost arrays
+            int[] swap = cost;
+            cost = newcost;
+            newcost = swap;
+        }
+
+        // the distance is the cost for transforming all letters in both strings
+        return cost[len0 - 1];
+    }
+}