Initial implementation of OptimalStringAlignment, with example

Author: MpoMp

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

@@ -0,0 +1,96 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2016 Thibault Debatty.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * 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.StringDistance;
+import net.jcip.annotations.Immutable;
+
+/**
+ * Implementation of the the Optimal String Alignment (sometimes called the
+ * restricted edit distance) variant of the Damerau-Levenshtein distance.
+ *
+ * The difference between the two algorithms consists in that the Optimal String
+ * Alignment algorithm computes the number of edit operations needed to make the
+ * strings equal under the condition that no substring is edited more than once,
+ * whereas Damerau-Levenshtein presents no such restriction.
+ *
+ * @author Michail Bogdanos
+ */
+@Immutable
+public final class OptimalStringAlignment implements StringDistance {
+
+    /**
+     * 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) while no substring is edited more than once.
+     *
+     * @param s1 the first input string
+     * @param s2 the second input string
+     * @return the OSA distance
+     */
+    public final double distance(final String s1, final String s2) {
+
+        // Create the distance matrix H[0 .. s1.length+1][0 .. s2.length+1]
+        int[][] d = new int[s1.length() + 2][s2.length() + 2];
+
+        //@TODO: check special cases
+        //initialize top row and leftmost column
+        for (int i = 0; i <= s1.length(); i++) {
+            d[i][0] = i;
+        }
+        for (int j = 0; j <= s2.length(); j++) {
+            d[0][j] = j;
+        }
+
+        //fill the distance matrix
+        int cost;
+
+        for (int i = 1; i <= s1.length(); i++) {
+            for (int j = 1; j <= s2.length(); j++) {
+
+                //if s1[i - 1] = s2[j - 1] then cost = 0, else cost = 1
+                cost = (s1.charAt(i - 1) == s2.charAt(j - 1)) ? 0 : 1;
+
+                d[i][j] = min(
+                        d[i - 1][j - 1] + cost, // substitution
+                        d[i][j - 1] + 1, // insertion
+                        d[i - 1][j] + 1 // deletion
+                        );
+                
+                //transposition check
+                if (i > 1 && j > 1 && s1.charAt(i-1) == s2.charAt(j-2) && s1.charAt(i-2) == s2.charAt(j-1)){
+                    d[i][j] = Math.min(d[i][j], d[i-2][j-2] + cost);
+                }
+            }
+        }
+
+        return d[s1.length() + 1][s2.length() + 1];
+    }
+
+    private static int min(
+            final int a, final int b, final int c) {
+        return Math.min(a, Math.min(b, c));
+    }
+}

src/main/java/info/debatty/java/stringsimilarity/examples/Examples.java

@@ -26,6 +26,7 @@
 import info.debatty.java.stringsimilarity.CharacterSubstitutionInterface;
 import info.debatty.java.stringsimilarity.Cosine;
 import info.debatty.java.stringsimilarity.Damerau;
+import info.debatty.java.stringsimilarity.OptimalStringAlignment;
 import info.debatty.java.stringsimilarity.Jaccard;
 import info.debatty.java.stringsimilarity.JaroWinkler;
 import info.debatty.java.stringsimilarity.KShingling;
@@ -109,6 +110,25 @@ public static void main(String[] args) {
 
         // All different
         System.out.println(damerau.distance("ABCDEF", "POIU"));
+        
+        // OptimalStringAlignment
+        // =======
+        OptimalStringAlignment osa = new OptimalStringAlignment();
+
+        // 1 substitution
+        System.out.println(osa.distance("ABCDEF", "ABDCEF"));
+
+        // 2 substitutions
+        System.out.println(osa.distance("ABCDEF", "BACDFE"));
+
+        // 1 deletion
+        System.out.println(osa.distance("ABCDEF", "ABCDE"));
+        System.out.println(osa.distance("ABCDEF", "BCDEF"));
+
+        System.out.println(osa.distance("ABCDEF", "ABCGDEF"));
+
+        // All different
+        System.out.println(osa.distance("ABCDEF", "POIU"));
 
         // Longest Common Subsequence
         // ==========================