Checked and marked as Immutable + code clean

Author: tdebatty

src/main/java/info/debatty/java/stringsimilarity/JaroWinkler.java

@@ -3,39 +3,43 @@
 import info.debatty.java.stringsimilarity.interfaces.NormalizedStringSimilarity;
 import info.debatty.java.stringsimilarity.interfaces.NormalizedStringDistance;
 import java.util.Arrays;
+import net.jcip.annotations.Immutable;
 
 /**
- * The Jaro–Winkler distance metric is designed and best suited for short 
- * strings such as person names, and to detect typos; it is (roughly) a 
- * variation of Damerau-Levenshtein, where the substitution of 2 close 
+ * The Jaro–Winkler distance metric is designed and best suited for short
+ * strings such as person names, and to detect typos; it is (roughly) a
+ * variation of Damerau-Levenshtein, where the substitution of 2 close
  * characters is considered less important then the substitution of 2 characters
  * that a far from each other.
- * Jaro-Winkler was developed in the area of record linkage (duplicate 
+ * Jaro-Winkler was developed in the area of record linkage (duplicate
  * detection) (Winkler, 1990). It returns a value in the interval [0.0, 1.0].
  * The distance is computed as 1 - Jaro-Winkler similarity.
  * @author Thibault Debatty
  */
-public class JaroWinkler implements NormalizedStringSimilarity, NormalizedStringDistance {
-    
+@Immutable
+public class JaroWinkler
+        implements NormalizedStringSimilarity, NormalizedStringDistance {
 
+    private static final double DEFAULT_THRESHOLD = 0.7;
+    private static final int THREE = 3;
+    private static final double JW_COEF = 0.1;
+    private final double threshold;
+
+    /**
+     * Instantiate with default threshold (0.7).
+     *
+     */
     public JaroWinkler() {
-        
+        this.threshold = DEFAULT_THRESHOLD;
     }
-    
-    public JaroWinkler(double threshold) {
-        this.setThreshold(threshold);
-    }
-    
-    private double threshold = 0.7;
-    
+
     /**
-     * Sets the threshold used to determine when Winkler bonus should be used.
-     * Set to a negative value to get the Jaro distance.
-     * Default value is 0.7
-     *
-     * @param threshold the new value of the threshold
+     * Instantiate with given threshold to determine when Winkler bonus should
+     * be used.
+     * Set threshold to a negative value to get the Jaro distance.
+     * @param threshold
      */
-    public final void setThreshold(double threshold) {
+    public JaroWinkler(final double threshold) {
         this.threshold = threshold;
     }
 
@@ -45,29 +49,44 @@ public final void setThreshold(double threshold) {
      *
      * @return the current value of the threshold
      */
-    public double getThreshold() {
+    public final double getThreshold() {
         return threshold;
     }
 
-    public double similarity(String s1, String s2) {
+    /**
+     * Compute JW similarity.
+     * @param s1
+     * @param s2
+     * @return
+     */
+    public final double similarity(final String s1, final 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);
+        double j = ((m / s1.length() + m / s2.length() + (m - mtp[1]) / m))
+                / THREE;
+        double jw = j;
+
+        if (j > getThreshold()) {
+            jw = j + Math.min(JW_COEF, 1.0 / mtp[THREE]) * mtp[2] * (1 - j);
+        }
         return jw;
     }
-    
-    
-    public double distance(String s1, String s2) {
+
+
+    /**
+     * Return 1 - similarity.
+     * @param s1
+     * @param s2
+     * @return
+     */
+    public final double distance(final String s1, final String s2) {
         return 1.0 - similarity(s1, s2);
     }
 
-
-    private int[] matches(String s1, String s2) {
+    private int[] matches(final String s1, final String s2) {
         String max, min;
         if (s1.length() > s2.length()) {
             max = s1;

src/main/java/info/debatty/java/stringsimilarity/LongestCommonSubsequence.java

@@ -1,6 +1,7 @@
 package info.debatty.java.stringsimilarity;
 
 import info.debatty.java.stringsimilarity.interfaces.StringDistance;
+import net.jcip.annotations.Immutable;
 
 /**
  * The longest common subsequence (LCS) problem consists in finding the longest
@@ -22,18 +23,19 @@
  *
  * @author Thibault Debatty
  */
+@Immutable
 public class LongestCommonSubsequence implements StringDistance {
 
     /**
      * Return the LCS distance between strings s1 and s2, computed as |s1| +
-     * |s2| - 2 * |LCS(s1, s2)|
+     * |s2| - 2 * |LCS(s1, s2)|.
      *
      * @param s1
      * @param s2
      * @return the LCS distance between strings s1 and s2, computed as |s1| +
      * |s2| - 2 * |LCS(s1, s2)|
      */
-    public double distance(String s1, String s2) {
+    public final double distance(final String s1, final String s2) {
         return s1.length() + s2.length() - 2 * length(s1, s2);
     }
 
@@ -45,16 +47,16 @@ public double distance(String s1, String s2) {
      * @param s2
      * @return the length of LCS(s1, s2)
      */
-    protected int length(String s1, String s2) {
+    public final int length(final String s1, final String s2) {
         /* function LCSLength(X[1..m], Y[1..n])
          C = array(0..m, 0..n)
-        
+
          for i := 0..m
          C[i,0] = 0
-        
+
          for j := 0..n
          C[0,j] = 0
-        
+
          for i := 1..m
          for j := 1..n
          if X[i] = Y[j]
@@ -65,30 +67,30 @@ protected int length(String s1, String s2) {
          */
         int m = s1.length();
         int n = s2.length();
-        char[] X = s1.toCharArray();
-        char[] Y = s2.toCharArray();
+        char[] x = s1.toCharArray();
+        char[] y = s2.toCharArray();
 
-        int[][] C = new int[m + 1][n + 1];
+        int[][] c = new int[m + 1][n + 1];
 
         for (int i = 0; i <= m; i++) {
-            C[i][0] = 0;
+            c[i][0] = 0;
         }
 
         for (int j = 0; j <= n; j++) {
-            C[0][j] = 0;
+            c[0][j] = 0;
         }
 
         for (int i = 1; i <= m; i++) {
             for (int j = 1; j <= n; j++) {
-                if (X[i - 1] == Y[j - 1]) {
-                    C[i][j] = C[i - 1][j - 1] + 1;
+                if (x[i - 1] == y[j - 1]) {
+                    c[i][j] = c[i - 1][j - 1] + 1;
 
                 } else {
-                    C[i][j] = Math.max(C[i][j - 1], C[i - 1][j]);
+                    c[i][j] = Math.max(c[i][j - 1], c[i - 1][j]);
                 }
             }
         }
 
-        return C[m][n];
+        return c[m][n];
     }
 }

src/main/java/info/debatty/java/stringsimilarity/MetricLCS.java

@@ -26,26 +26,31 @@
 
 import info.debatty.java.stringsimilarity.interfaces.MetricStringDistance;
 import info.debatty.java.stringsimilarity.interfaces.NormalizedStringDistance;
+import net.jcip.annotations.Immutable;
 
 /**
- * Distance metric based on Longest Common Subsequence, from the notes "An 
+ * Distance metric based on Longest Common Subsequence, from the notes "An
  * LCS-based string metric" by Daniel Bakkelund.
  * @author Thibault Debatty
  */
-public class MetricLCS implements MetricStringDistance, NormalizedStringDistance {
+@Immutable
+public class MetricLCS
+    implements MetricStringDistance, NormalizedStringDistance {
 
     private final LongestCommonSubsequence lcs = new LongestCommonSubsequence();
-    
+
     /**
-     * Distance metric based on Longest Common Subsequence, computed as 
-     * 1 - |LCS(s1, s2)| / max(|s1|, |s2|)
+     * Distance metric based on Longest Common Subsequence, computed as
+     * 1 - |LCS(s1, s2)| / max(|s1|, |s2|).
      * @param s1
      * @param s2
-     * @return 
+     * @return
      */
-    public double distance(String s1, String s2) {
-        return 1.0 - ((double) lcs.length(s1, s2)) / Math.max(s1.length(), s2.length());
-                
+    public final double distance(final String s1, final String s2) {
+        return 1.0
+                - (1.0 * lcs.length(s1, s2))
+                / Math.max(s1.length(), s2.length());
+
     }
-    
+
 }

src/test/java/info/debatty/java/stringsimilarity/JaroWinklerTest.java

@@ -24,10 +24,6 @@
 
 package info.debatty.java.stringsimilarity;
 
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Before;
-import org.junit.BeforeClass;
 import org.junit.Test;
 import static org.junit.Assert.*;
 
@@ -42,10 +38,17 @@ public class JaroWinklerTest {
      * Test of similarity method, of class JaroWinkler.
      */
     @Test
-    public void testSimilarity() {
+    public final void testSimilarity() {
         System.out.println("similarity");
         JaroWinkler instance = new JaroWinkler();
-        assertEquals(0.9740740656852722, instance.similarity("My string", "My tsring"), 0.0);
-        assertEquals(0.8962963223457336, instance.similarity("My string", "My ntrisg"), 0.0);
+        assertEquals(
+                0.974074,
+                instance.similarity("My string", "My tsring"),
+                0.000001);
+
+        assertEquals(
+                0.896296,
+                instance.similarity("My string", "My ntrisg"),
+                0.000001);
     }
 }