Big refactor:

multiple interfaces

Author: tdebatty

README.md

@@ -24,14 +24,15 @@
 
 package info.debatty.java.stringsimilarity;
 
+import info.debatty.java.stringsimilarity.interfaces.NormalizedStringSimilarity;
+import info.debatty.java.stringsimilarity.interfaces.NormalizedStringDistance;
+
 /**
  * @author Thibault Debatty
  */
-public class Cosine extends SetBasedStringSimilarity {
+public class Cosine extends ShingleBased implements 
+        NormalizedStringDistance, NormalizedStringSimilarity{
 
-    /**
-     * @param args the command line arguments
-     */
     public static void main(String[] args) {
         Cosine cos = new Cosine(3);
 
@@ -49,10 +50,12 @@ public static void main(String[] args) {
         // 1  1
         // similarity = .95
         System.out.println(cos.similarity("ABAB", "BAB"));
+        
+        
     }
 
     /**
-     * Implements Cosine Similarity.
+     * 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.
@@ -64,19 +67,20 @@ public Cosine(int k) {
     }
 
     public Cosine() {
-        super(3);
+        super();
     }
-
-
-    public double similarity(int[] profile1, int[] profile2) {
-        
+    
+    
+    public double similarity(String s1, String s2) {
+        KShingling ks = new KShingling(k);
+        int[] profile1 = ks.getArrayProfile(s1);
+        int[] profile2 = ks.getArrayProfile(s2);
+     
         return dotProduct(profile1, profile2) / (norm(profile1) * norm(profile2));
     }
-
-
 
     /**
-     * Compute the norm L2 : sqrt(Sum_i( v_i^2))
+     * Compute the norm L2 : sqrt(Sum_i( v_i²))
      * @param profile
      * @return L2 norm
      */
@@ -101,4 +105,9 @@ protected static double dotProduct(int[] profile1, int[] profile2) {
         }
         return agg;
     }
+
+    public double distance(String s1, String s2) {
+        return 1.0 - similarity(s1, s2);
+    }
+    
 }

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

@@ -24,6 +24,7 @@
 package info.debatty.java.stringsimilarity;
 
 import java.util.HashMap;
+import info.debatty.java.stringsimilarity.interfaces.StringDistance;
 
 /**
  * Implementation of Damerau-Levenshtein distance, computed as the 
@@ -34,38 +35,34 @@
  * This is not to be confused with the optimal string alignment distance, which 
  * is an extension where no substring can be edited more than once.
  * 
+ * Also, Damerau-Levenshting does not respect triangle inequality, and is thus 
+ * not a metric distance.
+ * 
  * @author Thibault Debatty
  */
-public class Damerau implements StringSimilarityInterface {
+public class Damerau implements StringDistance {
 
-    /**
-     * @param args the command line arguments
-     */
+    
     public static void main(String[] args) {
 
         Damerau d = new Damerau();
-        // 1 switch
-        System.out.println(d.absoluteDistance("ABCDEF", "ABDCEF"));
 
-        // 2 switches
-        System.out.println(d.absoluteDistance("ABCDEF", "BACDFE"));
+        // 1 substitution
+        System.out.println(d.distance("ABCDEF", "ABDCEF"));
 
-        // 1 deletion
-        System.out.println(d.absoluteDistance("ABCDEF", "ABCDE"));
+        // 2 substitutions
+        System.out.println(d.distance("ABCDEF", "BACDFE"));
 
         // 1 deletion
-        System.out.println(d.absoluteDistance("ABCDEF", "BCDEF"));
-        System.out.println(d.absoluteDistance("ABCDEF", "ABCGDEF"));
-        System.out.println(d.absoluteDistance("ABCDEF", "BCDAEF"));
-        
-        System.out.println(d.distance("ABCDEF", "GHABCDE"));
+        System.out.println(d.distance("ABCDEF", "ABCDE"));
+        System.out.println(d.distance("ABCDEF", "BCDEF"));
+        System.out.println(d.distance("ABCDEF", "ABCGDEF"));
 
         // All different
-        System.out.println(d.absoluteDistance("ABCDEF", "POIU"));
-        System.out.println(d.similarity("ABCDEF", "POIU"));
+        System.out.println(d.distance("ABCDEF", "POIU"));
     }
 
-    public int absoluteDistance(String s1, String s2) {
+    public double distance(String s1, String s2) {
 
         // INFinite distance is the max possible distance
         int INF = s1.length() + s2.length();
@@ -128,14 +125,6 @@ public int absoluteDistance(String s1, String s2) {
 
         return H[s1.length() + 1][s2.length() + 1];
     }
-
-    public double similarity(String s1, String s2) {
-        return 1.0 - distance(s1, s2);
-    }
-
-    public double distance(String s1, String s2) {
-        return (double) absoluteDistance(s1, s2) / Math.max(s1.length(), s2.length());
-    }
 
     protected static int min(int a, int b, int c, int d) {
         return Math.min(a, Math.min(b, Math.min(c, d)));

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

@@ -24,15 +24,17 @@
 
 package info.debatty.java.stringsimilarity;
 
+import info.debatty.java.stringsimilarity.interfaces.MetricStringDistance;
+import info.debatty.java.stringsimilarity.interfaces.NormalizedStringSimilarity;
+import info.debatty.java.stringsimilarity.interfaces.NormalizedStringDistance;
+
 /**
  * 
  * @author Thibault Debatty
  */
-public class Jaccard extends SetBasedStringSimilarity {
+public class Jaccard extends ShingleBased implements 
+        MetricStringDistance, NormalizedStringDistance, NormalizedStringSimilarity {
 
-    /**
-     * @param args the command line arguments
-     */
     public static void main(String[] args) {
         Jaccard j2 = new Jaccard(2);
 
@@ -41,10 +43,9 @@ public static void main(String[] args) {
         // 1  1  1  0  1
         // => 3 / 5 = 0.6
         System.out.println(j2.similarity("ABCDE", "ABCDF"));
+        
     }
 
-    
-    
     /**
      * 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|.
@@ -56,25 +57,19 @@ public Jaccard(int k) {
         super(k);
     }
 
+    /**
+     * 
+     */
     public Jaccard() {
-        super(3);
+        super();
     }
 
 
-    /**
-     * Compute and return the Jaccard index similarity between two string profiles.
-     * 
-     * E.g:
-     * ks = new KShingling(4)
-     * profile1 = ks.getProfile("My String")
-     * profile2 = ks.getProfile("My other string")
-     * similarity = jaccard.similarity(profile1, profile2)
-     * 
-     * @param profile1
-     * @param profile2
-     * @return 
-     */
-    public double similarity(int[] profile1, int[] profile2) {
+    public double similarity(String s1, String s2) {
+        KShingling ks = new KShingling(k);
+        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);
@@ -94,4 +89,9 @@ public double similarity(int[] profile1, int[] profile2) {
 
         return (double) inter / union;
     }
+    
+
+    public double distance(String s1, String s2) {
+        return 1.0 - similarity(s1, s2);
+    }
 }

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

@@ -1,67 +1,37 @@
 package info.debatty.java.stringsimilarity;
 
+import info.debatty.java.stringsimilarity.interfaces.NormalizedStringSimilarity;
+import info.debatty.java.stringsimilarity.interfaces.NormalizedStringDistance;
 import java.util.Arrays;
 
 /**
  *
  * @author tibo
  */
-public class JaroWinkler implements StringSimilarityInterface {
+public class JaroWinkler implements NormalizedStringSimilarity, NormalizedStringDistance {
 
 
     public static void main(String[] args) {
         JaroWinkler jw = new JaroWinkler();
 
-        System.out.println(jw.distance("My string", "My $tring"));
-        System.out.println(jw.similarity("My string", "My $tring"));
+        // substitution of s and t
+        System.out.println(jw.similarity("My string", "My tsring"));
+        
+        // substitution of s and n
+        System.out.println(jw.similarity("My string", "My ntrisg"));
     }
 
-    /**
-     * Jaro-Winkler is string edit distance that was developed in the area of 
-     * record linkage (duplicate detection) (Winkler, 1990). 
-     * 
-     * The Jaro–Winkler distance metric is designed and best suited for short 
-     * strings such as person names, and to detect typos.
-     * 
-     * 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.similarity(s0, s1);
-    }
 
-    private double threshold = 0.7;
-    
     public JaroWinkler() {
 
     }
 
     public JaroWinkler(double threshold) {
         this.setThreshold(threshold);
     }
-
-    @Override
-    public double similarity(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;
-    }
 
-    @Override
-    public double distance(String s1, String s2) {
-        return 1.0 - similarity(s1, s2);
-    }
-
+    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.
@@ -83,6 +53,24 @@ public double getThreshold() {
         return threshold;
     }
 
+    public double similarity(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;
+    }
+    
+    
+    public double distance(String s1, String s2) {
+        return 1.0 - similarity(s1, s2);
+    }
+
+
     private int[] matches(String s1, String s2) {
         String max, min;
         if (s1.length() > s2.length()) {