Catch up to 2.0.0 release of upstream project as of commit 1924ab8. Implement Ratcliff-Obserhelp algorithm. Add missing SIFT4 example to README. Fix documentation issue #17.

Author: paulirwin

F23.StringSimilarity.sln.DotSettings

@@ -1,2 +1,4 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=Levenshtein/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Levenshtein/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Obershelp/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Ratcliff/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

README.md

@@ -25,6 +25,9 @@ A library implementing different string similarity and distance measures. A doze
   * [Cosine similarity](#shingle-n-gram-based-algorithms)
   * [Jaccard index](#shingle-n-gram-based-algorithms)
   * [Sorensen-Dice coefficient](#shingle-n-gram-based-algorithms)
+* [Ratcliff-Obershelp](#ratcliff-obershelp)
+* [Experimental](#experimental)
+  * [SIFT4](#sift4)
 * [License](#license)
 
 ## Download
@@ -52,6 +55,7 @@ The main characteristics of each implemented algorithm are presented below. The
 | [Cosine similarity](#cosine-similarity) 				|similarity<br>distance | Yes  			| No  		| Profile | O(m+n) |
 | [Jaccard index](#jaccard-index)				|similarity<br>distance | Yes  			| Yes  		| Set	  | O(m+n) |
 | [Sorensen-Dice coefficient](#sorensen-dice-coefficient) 	|similarity<br>distance | Yes 			| No 		| Set	  | O(m+n) |
+| [Ratcliff-Obershelp](#ratcliff-obershelp) |similarity<br>distance | Yes | No | | ? | |
 
 [1] In this library, Levenshtein edit distance, LCS distance and their sibblings are computed using the **dynamic programming** method, which has a cost O(m.n). For Levenshtein distance, the algorithm is sometimes called **Wagner-Fischer algorithm** ("The string-to-string correction problem", 1974). The original algorithm uses a matrix of size m x n to store the Levenshtein distance between string prefixes.
 
@@ -335,7 +339,7 @@ public class Program
 {
     public static void Main(string[] args)
     {   
-        // produces 0.416666
+        // produces 0.583333
         var twogram = new NGram(2);
         Console.WriteLine(twogram.Distance("ABCD", "ABTUIO"));
 
@@ -427,6 +431,64 @@ Similar to Jaccard index, but this time the similarity is computed as 2 * |V1 in
 
 Distance is computed as 1 - cosine similarity.
 
+## Ratcliff-Obershelp
+Ratcliff/Obershelp Pattern Recognition, also known as Gestalt Pattern Matching, is a string-matching algorithm for determining the similarity of two strings. It was developed in 1983 by John W. Ratcliff and John A. Obershelp and published in the Dr. Dobb's Journal in July 1988
+
+Ratcliff/Obershelp computes the similarity between 2 strings, and the returned value lies in the interval [0.0, 1.0].
+
+The distance is computed as 1 - Ratcliff/Obershelp similarity.
+
+```cs
+using System;
+using F23.StringSimilarity;
+
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        var ro = new RatcliffObershelp();
+        
+        // substitution of s and t
+        Console.WriteLine(ro.Similarity("My string", "My tsring"));
+        
+        // substitution of s and n
+        Console.WriteLine(ro.Similarity("My string", "My ntrisg"));
+    }
+}
+```
+
+will produce:
+
+```
+0.8888888888888888
+0.7777777777777778
+```
+
+## Experimental
+
+### SIFT4
+SIFT4 is a general purpose string distance algorithm inspired by JaroWinkler and Longest Common Subsequence. It was developed to produce a distance measure that matches as close as possible to the human perception of string distance. Hence it takes into account elements like character substitution, character distance, longest common subsequence etc. It was developed using experimental testing, and without theoretical background.
+
+```cs
+using System;
+using System.Diagnostics;
+using F23.StringSimilarity;
+
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        var s1 = "This is the first string";
+        var s2 = "And this is another string";
+        var sift4 = new Sift4();
+        sift4.MaxOffset = 5;
+        double expResult = 11.0;
+        double result = sift4.Distance(s1, s2);
+        Debug.Assert(Math.Abs(result - expResult) < 0.1);
+    }
+}
+```
+
 ## License
 
 This code is licensed under the MIT license.

src/F23.StringSimilarity/Experimental/Sift4.cs

@@ -32,7 +32,8 @@ namespace F23.StringSimilarity.Experimental
     /// Sift4 - a general purpose string distance algorithm inspired by JaroWinkler
     /// and Longest Common Subsequence.
     /// Original JavaScript algorithm by siderite, java port by Nathan Fischer 2016.
-    /// https://siderite.blogspot.com/2014/11/super-fast-and-accurate-string-distance.html
+    /// https://siderite.dev/blog/super-fast-and-accurate-string-distance.html
+    /// https://blackdoor.github.io/blog/sift4-java/
     /// </summary>
     public class Sift4 : IStringDistance
     {
@@ -69,7 +70,8 @@ internal Offset(int c1, int c2, bool trans)
         /// Sift4 - a general purpose string distance algorithm inspired by JaroWinkler
         /// and Longest Common Subsequence.
         /// Original JavaScript algorithm by siderite, java port by Nathan Fischer 2016.
-        /// https://siderite.blogspot.com/2014/11/super-fast-and-accurate-string-distance.html
+        /// https://siderite.dev/blog/super-fast-and-accurate-string-distance.html
+        /// https://blackdoor.github.io/blog/sift4-java/
         /// </summary>
         /// <param name="s1"></param>
         /// <param name="s2"></param>

src/F23.StringSimilarity/RatcliffObershelp.cs

@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using F23.StringSimilarity.Interfaces;
+
+namespace F23.StringSimilarity
+{
+    /// <summary>
+    /// Ratcliff/Obershelp pattern recognition
+    /// 
+    /// The Ratcliff/Obershelp algorithm computes the similarity of two strings a
+    /// the doubled number of matching characters divided by the total number of
+    /// characters in the two strings.Matching characters are those in the longest
+    /// common subsequence plus, recursively, matching characters in the unmatched
+    /// region on either side of the longest common subsequence.
+    /// The Ratcliff/Obershelp distance is computed as 1 - Ratcliff/Obershelp
+    /// similarity.
+    ///
+    /// Author: Ligi https://github.com/dxpux (as a patch for fuzzystring)
+    /// Ported to java from .net by denmase
+    /// Ported back to .NET by paulirwin to retain compatibility with upstream Java project
+    /// </summary>
+    public class RatcliffObershelp : INormalizedStringSimilarity, INormalizedStringDistance
+    {
+        /// <summary>
+        /// Compute the Ratcliff-Obershelp similarity between strings.
+        /// </summary>
+        /// <param name="s1">The first string to compare.</param>
+        /// <param name="s2">The second string to compare.</param>
+        /// <returns>The RatcliffObershelp similarity in the range [0, 1]</returns>
+        /// <exception cref="System.ArgumentNullException">If s1 or s2 is null.</exception>
+        public double Similarity(string s1, string s2)
+        {
+            if (s1 == null)
+            {
+                throw new ArgumentNullException(nameof(s1), "s1 must not be null");
+            }
+
+            if (s2 == null)
+            {
+                throw new ArgumentNullException(nameof(s2), "s2 must not be null");
+            }
+
+            if (s1.Equals(s2))
+            {
+                return 1.0d;
+            }
+
+            var matches = GetMatchList(s1, s2);
+            int sumOfMatches = 0;
+
+            foreach (var match in matches)
+            {
+                sumOfMatches += match.Length;
+            }
+
+            return 2.0d * sumOfMatches / (s1.Length + s2.Length);
+        }
+
+        /// <summary>
+        /// Return 1 - similarity.
+        /// </summary>
+        /// <param name="s1">The first string to compare.</param>
+        /// <param name="s2">The second string to compare.</param>
+        /// <returns>1 - similarity</returns>
+        /// <exception cref="System.ArgumentNullException">If s1 or s2 is null.</exception>
+        public double Distance(string s1, string s2)
+        {
+            return 1.0d - Similarity(s1, s2);
+        }
+
+        private static IList<string> GetMatchList(string s1, string s2)
+        {
+            var list = new List<string>();
+            var match = FrontMaxMatch(s1, s2);
+
+            if (match.Length > 0)
+            {
+                var frontSource = s1.Substring(0, s1.IndexOf(match, StringComparison.Ordinal));
+                var frontTarget = s2.Substring(0, s2.IndexOf(match, StringComparison.Ordinal));
+                var frontQueue = GetMatchList(frontSource, frontTarget);
+
+                var endSource = s1.Substring(s1.IndexOf(match, StringComparison.Ordinal) + match.Length);
+                var endTarget = s2.Substring(s2.IndexOf(match, StringComparison.Ordinal) + match.Length);
+                var endQueue = GetMatchList(endSource, endTarget);
+
+                list.Add(match);
+                list.AddRange(frontQueue);
+                list.AddRange(endQueue);
+            }
+
+            return list;
+        }
+
+        private static string FrontMaxMatch(string s1, string s2)
+        {
+            int longest = 0;
+            var longestSubstring = "";
+
+            for (int i = 0; i < s1.Length; ++i)
+            {
+                for (int j = i + 1; j <= s1.Length; ++j)
+                {
+                    var substring = s1.Substring(i, j - i);
+                    if (s2.Contains(substring) && substring.Length > longest)
+                    {
+                        longest = substring.Length;
+                        longestSubstring = substring;
+                    }
+                }
+            }
+
+            return longestSubstring;
+        }
+    }
+}

test/F23.StringSimilarity.Tests/CosineTest.cs

@@ -99,9 +99,32 @@ public async Task TestLargeString()
         public void TestDistance()
         {
             var instance = new Cosine();
+
+            double result = instance.Distance("ABC", "ABCE");
+            Assert.Equal(0.29, result, 2);
+
             NullEmptyTests.TestDistance(instance);
+        }
+
+        [Fact]
+        public void TestDistanceSmallString()
+        {
+            var instance = new Cosine(3);
+            double result = instance.Distance("AB", "ABCE");
+            Assert.Equal(1, result, 5);
+        }
+
+        [Fact]
+        public async Task TestDistanceLargeString()
+        {
+            var cos = new Cosine();
+
+            // read from 2 text files
+            var string1 = await ReadResourceFileAsync("71816-2.txt");
+            var string2 = await ReadResourceFileAsync("11328-1.txt");
+            double similarity = cos.Distance(string1, string2);
 
-            // TODO: regular (non-null/empty) distance tests
+            Assert.Equal(0.1885, similarity, 3);
         }
 
         [Fact]

test/F23.StringSimilarity.Tests/RatcliffObershelpTest.cs

@@ -0,0 +1,97 @@
+using F23.StringSimilarity.Tests.TestUtil;
+using Xunit;
+
+namespace F23.StringSimilarity.Tests
+{
+    public class RatcliffObershelpTest
+    {
+        [Fact]
+        public void TestSimilarity()
+        {
+            var instance = new RatcliffObershelp();
+
+            // test data from other algorithms
+            // "My string" vs "My tsring"
+            // Substrings:
+            // "ring" ==> 4, "My s" ==> 3, "s" ==> 1
+            // Ratcliff-Obershelp = 2*(sum of substrings)/(length of s1 + length of s2)
+            //                    = 2*(4 + 3 + 1) / (9 + 9)
+            //                    = 16/18
+            //                    = 0.888888
+            // NOTE.NET: actual result is 0.8888888888 repeating, but Xunit rounds to 0.888889.
+            // Modified assertion from upstream Java code to reflect rounding difference between assertion APIs.
+            Assert.Equal(
+                    0.888889,
+                    instance.Similarity("My string", "My tsring"),
+                    6);
+
+            // test data from other algorithms
+            // "My string" vs "My tsring"
+            // Substrings:
+            // "My " ==> 3, "tri" ==> 3, "g" ==> 1
+            // Ratcliff-Obershelp = 2*(sum of substrings)/(length of s1 + length of s2)
+            //                    = 2*(3 + 3 + 1) / (9 + 9)
+            //                    = 14/18
+            //                    = 0.777778
+            Assert.Equal(
+                    0.777778,
+                    instance.Similarity("My string", "My ntrisg"),
+                    6);
+
+            // test data from essay by Ilya Ilyankou
+            // "Comparison of Jaro-Winkler and Ratcliff/Obershelp algorithms
+            // in spell check"
+            // https://ilyankou.files.wordpress.com/2015/06/ib-extended-essay.pdf
+            // p13, expected result is 0.857
+            Assert.Equal(
+                    0.857,
+                    instance.Similarity("MATEMATICA", "MATHEMATICS"),
+                    3);
+
+            // test data from stringmetric
+            // https://github.com/rockymadden/stringmetric
+            // expected output is 0.7368421052631579
+            Assert.Equal(
+                    0.736842,
+                    instance.Similarity("aleksander", "alexandre"),
+                    6);
+
+            // test data from stringmetric
+            // https://github.com/rockymadden/stringmetric
+            // expected output is 0.6666666666666666
+            // NOTE.NET: actual result is 0.6666666666 repeating, but Xunit rounds to 0.666667.
+            // Modified assertion from upstream Java code to reflect rounding difference between assertion APIs.
+            Assert.Equal(
+                    0.666667,
+                    instance.Similarity("pennsylvania", "pencilvaneya"),
+                    6);
+
+            // test data from wikipedia
+            // https://en.wikipedia.org/wiki/Gestalt_Pattern_Matching
+            // expected output is 14/18 = 0.7777777777777778
+            Assert.Equal(
+                    0.777778,
+                    instance.Similarity("WIKIMEDIA", "WIKIMANIA"),
+                    6);
+
+            // test data from wikipedia
+            // https://en.wikipedia.org/wiki/Gestalt_Pattern_Matching
+            // expected output is 24/40 = 0.65
+            Assert.Equal(
+                    0.6,
+                    instance.Similarity("GESTALT PATTERN MATCHING", "GESTALT PRACTICE"),
+                    6);
+
+            NullEmptyTests.TestSimilarity(instance);
+        }
+
+        [Fact]
+        public void TestDistance()
+        {
+            var instance = new RatcliffObershelp();
+            NullEmptyTests.TestDistance(instance);
+
+            // TODO: regular (non-null/empty) distance tests
+        }
+    }
+}