Marked classes as Immutable + code clean

Author: tdebatty

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

@@ -25,6 +25,7 @@
 
 import info.debatty.java.stringsimilarity.interfaces.NormalizedStringSimilarity;
 import info.debatty.java.stringsimilarity.interfaces.NormalizedStringDistance;
+import net.jcip.annotations.Immutable;
 
 /**
  * The similarity between the two strings is the cosine of the angle between
@@ -33,6 +34,7 @@
  *
  * @author Thibault Debatty
  */
+@Immutable
 public class Cosine extends ShingleBased implements
         NormalizedStringDistance, NormalizedStringSimilarity {
 
@@ -49,7 +51,11 @@ public Cosine(final int k) {
     }
 
     /**
-     *
+     * Implements Cosine Similarity between strings. The strings are first
+     * transformed in vectors of occurrences of k-shingles (sequences of k
+     * characters). In this n-dimensional space, the similarity between the two
+     * strings is the cosine of their respective vectors.
+     * Default k is 3.
      */
     public Cosine() {
         super();
@@ -63,10 +69,10 @@ public Cosine() {
      */
     public final double similarity(final String s1, final String s2) {
 
-        if (s1.length() < k || s2.length() < k) {
+        if (s1.length() < getK() || s2.length() < getK()) {
             return 0;
         }
-        KShingling ks = new KShingling(k);
+        KShingling ks = new KShingling(getK());
         int[] profile1 = ks.getArrayProfile(s1);
         int[] profile2 = ks.getArrayProfile(s2);
 
@@ -80,7 +86,7 @@ public final double similarity(final String s1, final String s2) {
      * @param profile
      * @return L2 norm
      */
-    protected static double norm(final int[] profile) {
+    private static double norm(final int[] profile) {
         double agg = 0;
 
         for (int v : profile) {
@@ -90,7 +96,7 @@ protected static double norm(final int[] profile) {
         return Math.sqrt(agg);
     }
 
-    protected static double dotProduct(
+    private static double dotProduct(
             final int[] profile1, final int[] profile2) {
 
         // profiles may not have the same length

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

@@ -25,14 +25,14 @@
 
 import info.debatty.java.stringsimilarity.interfaces.MetricStringDistance;
 import java.util.HashMap;
-import info.debatty.java.stringsimilarity.interfaces.StringDistance;
+import net.jcip.annotations.Immutable;
 
 /**
- * Implementation of Damerau-Levenshtein distance with transposition (also 
+ * Implementation of Damerau-Levenshtein distance with transposition (also
  * sometimes calls unrestricted Damerau-Levenshtein distance).
- * It is the minimum number of operations needed to transform one string into 
- * the other, where an operation is defined as an insertion, deletion, or 
- * substitution of a single character, or a transposition of two adjacent 
+ * It is the minimum number of operations needed to transform one string into
+ * the other, where an operation is defined as an insertion, deletion, or
+ * substitution of a single character, or a transposition of two adjacent
  * characters.
  * It does respect triangle inequality, and is thus a metric distance.
  *
@@ -41,73 +41,84 @@
  *
  * @author Thibault Debatty
  */
-public class Damerau implements StringDistance, MetricStringDistance {
-
-    public double distance(String s1, String s2) {
+@Immutable
+public class Damerau implements MetricStringDistance {
+
+    /**
+     * Compute the distance between strings: the minimum number of operations
+     * needed to transform one string into the other (insertion, deletion,
+     * substitution of a single character, or a transposition of two adjacent
+     * characters).
+     * @param s1
+     * @param s2
+     * @return
+     */
+    public final double distance(final String s1, final String s2) {
 
         // INFinite distance is the max possible distance
-        int INF = s1.length() + s2.length();
+        int inf = s1.length() + s2.length();
 
         // Create and initialize the character array indices
-        HashMap<Character, Integer> DA = new HashMap<Character, Integer>();
+        HashMap<Character, Integer> da = new HashMap<Character, Integer>();
 
         for (int d = 0; d < s1.length(); d++) {
-            if (!DA.containsKey(s1.charAt(d))) {
-                DA.put(s1.charAt(d), 0);
+            if (!da.containsKey(s1.charAt(d))) {
+                da.put(s1.charAt(d), 0);
             }
         }
 
         for (int d = 0; d < s2.length(); d++) {
-            if (!DA.containsKey(s2.charAt(d))) {
-                DA.put(s2.charAt(d), 0);
+            if (!da.containsKey(s2.charAt(d))) {
+                da.put(s2.charAt(d), 0);
             }
         }
 
         // Create the distance matrix H[0 .. s1.length+1][0 .. s2.length+1]
-        int[][] H = new int[s1.length() + 2][s2.length() + 2];
+        int[][] h = new int[s1.length() + 2][s2.length() + 2];
 
         // initialize the left and top edges of H
         for (int i = 0; i <= s1.length(); i++) {
-            H[i + 1][0] = INF;
-            H[i + 1][1] = i;
+            h[i + 1][0] = inf;
+            h[i + 1][1] = i;
         }
 
         for (int j = 0; j <= s2.length(); j++) {
-            H[0][j + 1] = INF;
-            H[1][j + 1] = j;
+            h[0][j + 1] = inf;
+            h[1][j + 1] = j;
 
         }
 
         // fill in the distance matrix H
         // look at each character in s1
         for (int i = 1; i <= s1.length(); i++) {
-            int DB = 0;
+            int db = 0;
 
             // look at each character in b
             for (int j = 1; j <= s2.length(); j++) {
-                int i1 = DA.get(s2.charAt(j - 1));
-                int j1 = DB;
+                int i1 = da.get(s2.charAt(j - 1));
+                int j1 = db;
 
                 int cost = 1;
                 if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                     cost = 0;
-                    DB = j;
+                    db = j;
                 }
 
-                H[i + 1][j + 1] = min(
-                        H[i][j] + cost, // substitution
-                        H[i + 1][j] + 1, // insertion
-                        H[i][j + 1] + 1, // deletion
-                        H[i1][j1] + (i - i1 - 1) + 1 + (j - j1 - 1));
+                h[i + 1][j + 1] = min(
+                        h[i][j] + cost, // substitution
+                        h[i + 1][j] + 1, // insertion
+                        h[i][j + 1] + 1, // deletion
+                        h[i1][j1] + (i - i1 - 1) + 1 + (j - j1 - 1));
             }
 
-            DA.put(s1.charAt(i - 1), i);
+            da.put(s1.charAt(i - 1), i);
         }
 
-        return H[s1.length() + 1][s2.length() + 1];
+        return h[s1.length() + 1][s2.length() + 1];
     }
 
-    protected static int min(int a, int b, int c, int d) {
+    private static int min(
+            final int a, final int b, final int c, final int d) {
         return Math.min(a, Math.min(b, Math.min(c, d)));
     }
 

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

@@ -27,66 +27,82 @@
 import info.debatty.java.stringsimilarity.interfaces.MetricStringDistance;
 import info.debatty.java.stringsimilarity.interfaces.NormalizedStringSimilarity;
 import info.debatty.java.stringsimilarity.interfaces.NormalizedStringDistance;
+import net.jcip.annotations.Immutable;
 
 /**
- * Each input string is converted into a set of n-grams, the Jaccard index is 
+ * Each input string is converted into a set of n-grams, the Jaccard index is
  * then computed as |V1 inter V2| / |V1 union V2|.
- * Like Q-Gram distance, the input strings are first converted into sets of 
- * n-grams (sequences of n characters, also called k-shingles), but this time 
- * the cardinality of each n-gram is not taken into account. 
+ * Like Q-Gram distance, the input strings are first converted into sets of
+ * n-grams (sequences of n characters, also called k-shingles), but this time
+ * the cardinality of each n-gram is not taken into account.
  * Distance is computed as 1 - cosine similarity.
  * Jaccard index is a metric distance.
  * @author Thibault Debatty
  */
-public class Jaccard extends ShingleBased implements 
-        MetricStringDistance, NormalizedStringDistance, NormalizedStringSimilarity {
-    
+@Immutable
+public class Jaccard extends ShingleBased implements
+        MetricStringDistance, NormalizedStringDistance,
+        NormalizedStringSimilarity {
+
     /**
      * The strings are first transformed into sets of k-shingles (sequences of k
      * characters), then Jaccard index is computed as |A inter B| / |A union B|.
      * The default value of k is 3.
-     * 
-     * @param k 
+     *
+     * @param k
      */
-    public Jaccard(int k) {
+    public Jaccard(final int k) {
         super(k);
     }
-    
+
     /**
-     * 
+     * The strings are first transformed into sets of k-shingles (sequences of k
+     * characters), then Jaccard index is computed as |A inter B| / |A union B|.
+     * The default value of k is 3.
      */
     public Jaccard() {
         super();
     }
 
-    
-    public double similarity(String s1, String s2) {
-        KShingling ks = new KShingling(k);
+    /**
+     * Compute jaccard index: |A inter B| / |A union B|.
+     * @param s1
+     * @param s2
+     * @return
+     */
+    public final double similarity(final String s1, final String s2) {
+        KShingling ks = new KShingling(getK());
         int[] profile1 = ks.getArrayProfile(s1);
         int[] profile2 = ks.getArrayProfile(s2);
-    
+
         int length = Math.max(profile1.length, profile2.length);
         profile1 = java.util.Arrays.copyOf(profile1, length);
         profile2 = java.util.Arrays.copyOf(profile2, length);
-        
+
         int inter = 0;
         int union = 0;
-        
+
         for (int i = 0; i < length; i++) {
             if (profile1[i] > 0 || profile2[i] > 0) {
                 union++;
-                
+
                 if (profile1[i] > 0 && profile2[i] > 0) {
                     inter++;
                 }
             }
         }
-    
-        return (double) inter / union;
+
+        return 1.0 * inter / union;
     }
-    
 
-    public double distance(String s1, String s2) {
+
+    /**
+     * Distance is computed as 1 - similarity.
+     * @param s1
+     * @param s2
+     * @return
+     */
+    public final double distance(final String s1, final String s2) {
         return 1.0 - similarity(s1, s2);
     }
 }