added tests for cosine, damerau and LCS

Author: tdebatty

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

@@ -21,87 +21,66 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-
 package info.debatty.java.stringsimilarity;
 
 import info.debatty.java.stringsimilarity.interfaces.NormalizedStringSimilarity;
 import info.debatty.java.stringsimilarity.interfaces.NormalizedStringDistance;
 
 /**
- * The similarity between the two strings is the cosine of the angle between 
+ * The similarity between the two strings is the cosine of the angle between
  * these two vectors representation. It is computed as V1 . V2 / (|V1| * |V2|)
  * The cosine distance is computed as 1 - cosine similarity.
+ *
  * @author Thibault Debatty
  */
-public class Cosine extends ShingleBased implements 
-        NormalizedStringDistance, NormalizedStringSimilarity{
+public class Cosine extends ShingleBased implements
+        NormalizedStringDistance, NormalizedStringSimilarity {
 
-    public static void main(String[] args) {
-        Cosine cos = new Cosine(3);
-        
-        // ABC BCE
-        // 1  0
-        // 1  1
-        // angle = 45°
-        // => similarity = .71
-        
-        System.out.println(cos.similarity("ABC", "ABCE"));
-        
-        cos = new Cosine(2);
-        // AB BA
-        // 2  1
-        // 1  1
-        // similarity = .95
-        System.out.println(cos.similarity("ABAB", "BAB"));
-        
-        
-    }
-    
     /**
-     * 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.
-     * 
-     * @param 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.
+     *
+     * @param k
      */
     public Cosine(int k) {
         super(k);
     }
-    
+
     public Cosine() {
         super();
     }
-    
-    
+
     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²))
+     *
      * @param profile
      * @return L2 norm
      */
     protected static double norm(int[] profile) {
         double agg = 0;
-        
+
         for (int v : profile) {
             agg += v * v;
         }
-        
+
         return Math.sqrt(agg);
     }
-    
+
     protected static double dotProduct(int[] profile1, int[] profile2) {
         int length = Math.max(profile1.length, profile2.length);
         profile1 = java.util.Arrays.copyOf(profile1, length);
         profile2 = java.util.Arrays.copyOf(profile2, length);
-        
+
         double agg = 0;
         for (int i = 0; i < length; i++) {
             agg += profile1[i] * profile2[i];
@@ -112,5 +91,5 @@ protected static double dotProduct(int[] profile1, int[] profile2) {
     public double distance(String s1, String s2) {
         return 1.0 - similarity(s1, s2);
     }
-    
+
 }

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

@@ -27,105 +27,85 @@
 import info.debatty.java.stringsimilarity.interfaces.StringDistance;
 
 /**
- * Implementation of Damerau-Levenshtein distance, computed as 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.
- * 
- * This is not to be confused with the optimal string alignment distance, which 
+ * Implementation of Damerau-Levenshtein distance, computed as 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.
+ *
+ * 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 
+ *
+ * Also, Damerau-Levenshting does not respect triangle inequality, and is thus
  * not a metric distance.
- * 
+ *
  * @author Thibault Debatty
  */
 public class Damerau implements StringDistance {
 
-    
-    public static void main(String[] args) {
-        
-        Damerau d = new Damerau();
-        
-        // 1 substitution
-        System.out.println(d.distance("ABCDEF", "ABDCEF"));
-        
-        // 2 substitutions
-        System.out.println(d.distance("ABCDEF", "BACDFE"));
-        
-        // 1 deletion
-        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.distance("ABCDEF", "POIU"));
-    }
-
     public double distance(String s1, String s2) {
 
         // INFinite distance is the max possible distance
         int INF = s1.length() + s2.length();
-        
+
         // Create and initialize the character array indices
         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);
             }
         }
-        
+
         for (int d = 0; d < s2.length(); d++) {
             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];
-        
+
         // 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;
         }
-        
+
         for (int j = 0; j <= s2.length(); 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;
-            
+
             // 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 cost = 1;
                 if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                     cost = 0;
                     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[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);
         }
-        
+
         return H[s1.length() + 1][s2.length() + 1];
     }
-    
+
     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/LongestCommonSubsequence.java

@@ -3,107 +3,92 @@
 import info.debatty.java.stringsimilarity.interfaces.StringDistance;
 
 /**
- * The longest common subsequence (LCS) problem consists in finding the 
- * longest subsequence common to two (or more) sequences. It differs from 
- * problems of finding common substrings: unlike substrings, subsequences are 
- * not required to occupy consecutive positions within the original sequences.
- * 
+ * The longest common subsequence (LCS) problem consists in finding the longest
+ * subsequence common to two (or more) sequences. It differs from problems of
+ * finding common substrings: unlike substrings, subsequences are not required
+ * to occupy consecutive positions within the original sequences.
+ *
  * It is used by the diff utility, by Git for reconciling multiple changes, etc.
- * 
- * The LCS distance between Strings X (length n) and Y (length m) is
- * n + m - 2 |LCS(X, Y)|
- * min = 0
- * max = n + m
- * 
- * LCS distance is equivalent to Levenshtein distance, when only insertion and 
- * deletion is allowed (no substitution), or when the cost of the substitution 
+ *
+ * The LCS distance between Strings X (length n) and Y (length m) is n + m - 2
+ * |LCS(X, Y)| min = 0 max = n + m
+ *
+ * LCS distance is equivalent to Levenshtein distance, when only insertion and
+ * deletion is allowed (no substitution), or when the cost of the substitution
  * is the double of the cost of an insertion or deletion.
- * 
- * ! This class currently implements the dynamic programming approach, which
- * has a space requirement O(m * n)!
- * 
+ *
+ * ! This class currently implements the dynamic programming approach, which has
+ * a space requirement O(m * n)!
+ *
  * @author Thibault Debatty
  */
 public class LongestCommonSubsequence implements StringDistance {
 
     /**
-     * @param args the command line arguments
-     */
-    public static void main(String[] args) {
-        LongestCommonSubsequence lcs = new LongestCommonSubsequence();
-        
-        // Will produce 4.0
-        System.out.println(lcs.distance("AGCAT", "GAC"));
-        
-        // Will produce 1.0
-        System.out.println(lcs.distance("AGCAT", "AGCT"));
-    }
-    
-    
-    /**
-     * Return the LCS distance between strings s1 and s2, 
-     * computed as |s1| + |s2| - 2 * |LCS(s1, s2)|
+     * Return the LCS distance between strings s1 and s2, computed as |s1| +
+     * |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)|
+     * @return the LCS distance between strings s1 and s2, computed as |s1| +
+     * |s2| - 2 * |LCS(s1, s2)|
      */
     public double distance(String s1, String s2) {
         return s1.length() + s2.length() - 2 * length(s1, s2);
     }
-    
+
     /**
      * Return the length of Longest Common Subsequence (LCS) between strings s1
      * and s2.
+     *
      * @param s1
      * @param s2
      * @return the length of LCS(s1, s2)
      */
     protected int length(String s1, String s2) {
         /* function LCSLength(X[1..m], Y[1..n])
-            C = array(0..m, 0..n)
+         C = array(0..m, 0..n)
         
-            for i := 0..m
-               C[i,0] = 0
+         for i := 0..m
+         C[i,0] = 0
         
-            for j := 0..n
-               C[0,j] = 0
+         for j := 0..n
+         C[0,j] = 0
         
-            for i := 1..m
-                for j := 1..n
-                    if X[i] = Y[j]
-                        C[i,j] := C[i-1,j-1] + 1
-                    else
-                        C[i,j] := max(C[i,j-1], C[i-1,j])
-            return C[m,n]
-        */
+         for i := 1..m
+         for j := 1..n
+         if X[i] = Y[j]
+         C[i,j] := C[i-1,j-1] + 1
+         else
+         C[i,j] := max(C[i,j-1], C[i-1,j])
+         return C[m,n]
+         */
         int m = s1.length();
         int n = s2.length();
         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;
         }
-        
+
         for (int j = 0; j <= n; j++) {
             C[0][j] = 0;
         }
-        
-        for (int i = 1; i <=m ; i++) {
+
+        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];
-        
     }
-    
 }