Catch up to upstream 1.2.0 release by adding early termination support to Levenshtein and WeightedLevenshtein

Author: paulirwin

src/F23.StringSimilarity/Levenshtein.cs

@@ -34,6 +34,17 @@ namespace F23.StringSimilarity
     /// change one string into the other.
     public class Levenshtein : IMetricStringDistance
     {
+        /// <summary>
+        /// Equivalent to Distance(s1, s2, Int32.MaxValue).
+        /// </summary>
+        /// <param name="s1">The first string to compare.</param>
+        /// <param name="s2">The second string to compare.</param>
+        /// <returns>The Levenshtein distance between strings</returns>
+        public double Distance(string s1, string s2)
+        {
+            return Distance(s1, s2, int.MaxValue);
+        }
+
         /// <summary>
         /// The Levenshtein distance, or edit distance, between two words is the
         /// Minimum number of single-character edits (insertions, deletions or
@@ -56,9 +67,14 @@ public class Levenshtein : IMetricStringDistance
         /// </summary>
         /// <param name="s1">The first string to compare.</param>
         /// <param name="s2">The second string to compare.</param>
+        /// <param name="limit">The maximum result to compute before stopping. This
+        /// means that the calculation can terminate early if you
+        /// only care about strings with a certain similarity.
+        /// Set this to Int32.MaxValue if you want to run the
+        /// calculation to completion in every case.</param>
         /// <returns>The Levenshtein distance between strings</returns>
         /// <exception cref="ArgumentNullException">If s1 or s2 is null.</exception>
-        public double Distance(string s1, string s2)
+        public double Distance(string s1, string s2, int limit)
         {
             if (s1 == null)
             {
@@ -105,6 +121,8 @@ public double Distance(string s1, string s2)
                 //   edit distance is delete (i+1) chars from s to match empty t
                 v1[0] = i + 1;
 
+                int minv1 = v1[0];
+
                 // use formula to fill in the rest of the row
                 for (int j = 0; j < s2.Length; j++)
                 {
@@ -118,10 +136,17 @@ public double Distance(string s1, string s2)
                             Math.Min(
                                     v0[j + 1] + 1,  // Cost of remove
                                     v0[j] + cost)); // Cost of substitution
+
+                    minv1 = Math.Min(minv1, v1[j + 1]);
+                }
+
+                if (minv1 >= limit)
+                {
+                    return limit;
                 }
 
                 // copy v1 (current row) to v0 (previous row) for next iteration
-                //System.arraycopy(v1, 0, v0, 0, v0.length);
+                // System.arraycopy(v1, 0, v0, 0, v0.length);
 
                 // Flip references to current and previous row
                 vtemp = v0;

src/F23.StringSimilarity/WeightedLevenshtein.cs

@@ -59,14 +59,30 @@ public WeightedLevenshtein(ICharacterSubstitution characterSubstitution,
             _characterInsDel = characterInsDel;
         }
 
+        /// <summary>
+        /// Equivalent to Distance(s1, s2, Double.MaxValue).
+        /// </summary>
+        /// <param name="s1">The first string to compare.</param>
+        /// <param name="s2">The second string to compare.</param>
+        /// <returns>The computed weighted Levenshtein distance.</returns>
+        public double Distance(string s1, string s2)
+        {
+            return Distance(s1, s2, double.MaxValue);
+        }
+
         /// <summary>
         /// Compute Levenshtein distance using provided weights for substitution.
         /// </summary>
         /// <param name="s1">The first string to compare.</param>
         /// <param name="s2">The second string to compare.</param>
+        /// <param name="limit">The maximum result to compute before stopping. This
+        /// means that the calculation can terminate early if you
+        /// only care about strings with a certain similarity.
+        /// Set this to Double.MaxValue if you want to run the
+        /// calculation to completion in every case.</param>
         /// <returns>The computed weighted Levenshtein distance.</returns>
         /// <exception cref="ArgumentNullException">If s1 or s2 is null.</exception>
-        public double Distance(string s1, string s2)
+        public double Distance(string s1, string s2, double limit)
         {
             if (s1 == null)
             {
@@ -93,7 +109,7 @@ public double Distance(string s1, string s2)
                 return s1.Length;
             }
 
-            // create two work vectors of integer distances
+            // create two work vectors of floating point (i.e. weighted) distances
             double[] v0 = new double[s2.Length + 1];
             double[] v1 = new double[s2.Length + 1];
             double[] vtemp;
@@ -118,6 +134,8 @@ public double Distance(string s1, string s2)
                 // to match empty t.
                 v1[0] = v0[0] + deletionCost;
 
+                double minv1 = v1[0];
+
                 // use formula to fill in the rest of the row
                 for (int j = 0; j < s2.Length; j++)
                 {
@@ -136,6 +154,13 @@ public double Distance(string s1, string s2)
                             Math.Min(
                                     v0[j + 1] + deletionCost, // Cost of deletion
                                     v0[j] + cost)); // Cost of substitution
+
+                    minv1 = Math.Min(minv1, v1[j + 1]);
+                }
+
+                if (minv1 >= limit)
+                {
+                    return limit;
                 }
 
                 // copy v1 (current row) to v0 (previous row) for next iteration

test/F23.StringSimilarity.Tests/LevenshteinTest.cs

@@ -42,6 +42,11 @@ public void TestDistance()
             Assert.Equal(expected: 2.0, actual: instance.Distance("My string", "M string2"));
             Assert.Equal(expected: 1.0, actual: instance.Distance("My string", "My $tring"));
 
+            // With limits.
+            Assert.Equal(2.0, instance.Distance("My string", "M string2", 4));
+            Assert.Equal(2.0, instance.Distance("My string", "M string2", 2));
+            Assert.Equal(1.0, instance.Distance("My string", "M string2", 1));
+
             NullEmptyTests.TestDistance(instance);
         }
     }

test/F23.StringSimilarity.Tests/WeightedLevenshteinTest.cs

@@ -42,6 +42,15 @@ public void TestDistance()
             Assert.Equal(1.0, instance.Distance("Strng", "String"), 1);
             Assert.Equal(1.0, instance.Distance("String", "Strng"), 1);
 
+            // With limits.
+            Assert.Equal(0.0, instance.Distance("String1", "String1", double.MaxValue), 1);
+            Assert.Equal(0.0, instance.Distance("String1", "String1", 2.0), 1);
+            Assert.Equal(1.5, instance.Distance("String1", "Srring2", double.MaxValue), 1);
+            Assert.Equal(1.5, instance.Distance("String1", "Srring2", 2.0), 1);
+            Assert.Equal(1.5, instance.Distance("String1", "Srring2", 1.5), 1);
+            Assert.Equal(1.0, instance.Distance("String1", "Srring2", 1.0), 1);
+            Assert.Equal(4.0, instance.Distance("String1", "Potato", 4.0), 1);
+
             NullEmptyTests.TestDistance(instance);
         }
 
@@ -54,6 +63,7 @@ public void TestDistanceCharacterInsDelInterface()
             Assert.Equal(0.0, instance.Distance("String1", "String1"), 1);
             Assert.Equal(0.5, instance.Distance("String1", "Srring1"), 1);
             Assert.Equal(1.5, instance.Distance("String1", "Srring2"), 1);
+
             // Cost of insert of 'i' is less than normal, so these scores are
             // different than testDistance above.  Note that the cost of delete
             // has been set differently than the cost of insert, so the distance
@@ -63,6 +73,15 @@ public void TestDistanceCharacterInsDelInterface()
             Assert.Equal(1.0, instance.Distance("Strig", "String"), 1);
             Assert.Equal(1.0, instance.Distance("String", "Strig"), 1);
 
+            // Same as above with limits.
+            Assert.Equal(0.0, instance.Distance("String1", "String1", double.MaxValue), 1);
+            Assert.Equal(0.0, instance.Distance("String1", "String1", 2.0), 1);
+            Assert.Equal(1.5, instance.Distance("String1", "Srring2", double.MaxValue), 1);
+            Assert.Equal(1.5, instance.Distance("String1", "Srring2", 2.0), 1);
+            Assert.Equal(1.5, instance.Distance("String1", "Srring2", 1.5), 1);
+            Assert.Equal(1.0, instance.Distance("String1", "Srring2", 1.0), 1);
+            Assert.Equal(4.0, instance.Distance("String1", "Potato", 4.0), 1);
+
             NullEmptyTests.TestDistance(instance);
         }