Merge pull request #6 from paulirwin/java-catchup

Changes to catch up to v0.18 (d3e6340) of upstream java repo

Author: jamesmblair

src/F23.StringSimilarity/Cosine.cs

@@ -68,7 +68,7 @@ public double Similarity(string s1, string s2)
          * @param profile
          * @return L2 norm
          */
-        protected static double Norm(int[] profile)
+        private static double Norm(int[] profile)
         {
             double agg = 0;
 
@@ -80,14 +80,14 @@ protected static double Norm(int[] profile)
             return Math.Sqrt(agg);
         }
 
-        protected static double DotProduct(int[] profile1, int[] profile2)
+        private static double DotProduct(int[] profile1, int[] profile2)
         {
             int length = Math.Min(profile1.Length, profile2.Length);
 
             double agg = 0;
             for (int i = 0; i < length; i++)
             {
-                agg += profile1[i] * profile2[i];
+                agg += (double)profile1[i] * profile2[i];
             }
             return agg;
         }

src/F23.StringSimilarity/Damerau.cs

@@ -40,82 +40,82 @@ namespace F23.StringSimilarity
     /// 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.
     /// </summary>
-    public class Damerau : IMetricStringDistance, IStringDistance
+    public class Damerau : IMetricStringDistance
     {
         public double Distance(string s1, string s2)
         {
             // Infinite distance is the max possible distance
-            int INFINITE = s1.Length + s2.Length;
+            int inf = s1.Length + s2.Length;
 
             // Create and initialize the character array indices
-            var DA = new Dictionary<char, int>();
+            var da = new Dictionary<char, int>();
 
             for (int d = 0; d < s1.Length; d++)
             {
-                if (!DA.ContainsKey(s1[d]))
+                if (!da.ContainsKey(s1[d]))
                 {
-                    DA[s1[d]] = 0;
+                    da[s1[d]] = 0;
                 }
             }
 
             for (int d = 0; d < s2.Length; d++)
             {
-                if (!DA.ContainsKey(s2[d]))
+                if (!da.ContainsKey(s2[d]))
                 {
-                    DA[s2[d]] = 0;
+                    da[s2[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];
+            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] = INFINITE;
-                H[i + 1, 1] = i;
+                h[i + 1, 0] = inf;
+                h[i + 1, 1] = i;
             }
 
             for (int j = 0; j <= s2.Length; j++)
             {
-                H[0, j + 1] = INFINITE;
-                H[1, j + 1] = 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;
+                int db = 0;
 
                 // Look at each character in b
                 for (int j = 1; j <= s2.Length; j++)
                 {
-                    int i1 = DA[s2[j - 1]];
-                    int j1 = DB;
+                    int i1 = da[s2[j - 1]];
+                    int j1 = db;
 
                     int cost = 1;
                     if (s1[i - 1] == s2[j - 1])
                     {
                         cost = 0;
-                        DB = j;
+                        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[i1, j1] + (i - i1 - 1) + 1 + (j - j1 - 1)
+                    h[i + 1, j + 1] = Min(
+                        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[s1[i - 1]] = i;
+                da[s1[i - 1]] = i;
             }
 
-            return H[s1.Length + 1, s2.Length + 1];
+            return h[s1.Length + 1, s2.Length + 1];
         }
 
-        protected static int Min(int a, int b, int c, int d)
+        private static int Min(int a, int b, int c, int d)
              => Math.Min(a, Math.Min(b, Math.Min(c, d)));
     }
 }

src/F23.StringSimilarity/F23.StringSimilarity.csproj

@@ -56,6 +56,7 @@
     <Compile Include="MetricLCS.cs" />
     <Compile Include="NGram.cs" />
     <Compile Include="NormalizedLevenshtein.cs" />
+    <Compile Include="OptimalStringAlignment.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="QGram.cs" />
     <Compile Include="ShingleBased.cs" />

src/F23.StringSimilarity/JaroWinkler.cs

@@ -45,7 +45,7 @@ public class JaroWinkler : INormalizedStringSimilarity, INormalizedStringDistanc
         /// <summary>
         /// The current value of the threshold used for adding the Winkler bonus. The default value is 0.7.
         /// </summary>
-        public double Threshold { get; private set; }
+        private double Threshold { get; }
 
         /// <summary>
         /// Creates a new instance with default threshold (0.7)

src/F23.StringSimilarity/MetricLCS.cs

@@ -44,10 +44,13 @@ public class MetricLCS : IMetricStringDistance, INormalizedStringDistance
         /// <returns>LCS distance metric</returns>
         public double Distance(string s1, string s2)
         {
+            int mLen = Math.Max(s1.Length, s2.Length);
+
+            if (mLen == 0) return 0.0;
+
             return 1.0
                     - (1.0 * lcs.Length(s1, s2))
-                    / Math.Max(s1.Length, s2.Length);
-
+                    / mLen;
         }
     }
 }

src/F23.StringSimilarity/NGram.cs

@@ -40,9 +40,10 @@ namespace F23.StringSimilarity
     /// </summary>
     public class NGram : INormalizedStringDistance
     {
+        private const int DEFAULT_N = 2;
         private readonly int n;
 
-        public NGram() : this(2) { }
+        public NGram() : this(DEFAULT_N) { }
 
         public NGram(int n)
         {
@@ -83,7 +84,7 @@ public double Distance(string s0, string s1)
             char[] sa = new char[sl + n - 1];
             float[] p; // 'previous' cost array, horizontally
             float[] d; // Cost array, horizontally
-            float[] _d; // Placeholder to assist in swapping p and d
+            float[] d2; // Placeholder to assist in swapping p and d
 
             // Construct sa with prefix
             for (int i1 = 0; i1 < sa.Length; i1++)
@@ -152,9 +153,9 @@ public double Distance(string s0, string s1)
                     d[i] = Math.Min(Math.Min(d[i - 1] + 1, p[i] + 1), p[i - 1] + ec);
                 }
                 // Copy current distance counts to 'previous row' distance counts
-                _d = p;
+                d2 = p;
                 p = d;
-                d = _d;
+                d = d2;
             }
 
             // Our last action in the above loop was to switch d and p, so p now

src/F23.StringSimilarity/NormalizedLevenshtein.cs

@@ -43,7 +43,13 @@ public class NormalizedLevenshtein : INormalizedStringDistance, INormalizedStrin
         /// <returns>The normalized Levenshtein distance</returns>
         ////
         public double Distance(string s1, string s2)
-            => l.Distance(s1, s2) / Math.Max(s1.Length, s2.Length);
+        {
+            int mLen = Math.Max(s1.Length, s2.Length);
+
+            if (mLen == 0) return 0.0;
+
+            return l.Distance(s1, s2) / mLen;
+        }
 
         /// <summary>
         /// Return 1 - distance.

src/F23.StringSimilarity/OptimalStringAlignment.cs

@@ -0,0 +1,94 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2016 feature[23]
+ *
+ * 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.
+ */
+
+using System;
+using F23.StringSimilarity.Interfaces;
+
+namespace F23.StringSimilarity
+{
+    public sealed class OptimalStringAlignment : IStringDistance
+    {
+        /// <summary>
+        /// 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.
+        /// </summary>
+        /// <param name="s1">the first input string</param>
+        /// <param name="s2">the second input string</param>
+        /// <returns>the OSA distance</returns>
+        public double Distance(string s1, string s2)
+        {
+            int n = s1.Length, m = s2.Length;
+            if (n == 0) return m;
+            if (m == 0) return n;
+
+            // Create the distance matrix H[0 .. s1.length+1][0 .. s2.length+1]
+            int[,] d = new int[s1.Length + 2, s2.Length + 2];
+
+            //initialize top row and leftmost column
+            for (int i = 0; i <= n; i++)
+            {
+                d[i, 0] = i;
+            }
+            for (int j = 0; j <= m; j++)
+            {
+                d[0, j] = j;
+            }
+
+            //fill the distance matrix
+            int cost;
+
+            for (int i = 1; i <= n; i++)
+            {
+                for (int j = 1; j <= m; j++)
+                {
+
+                    //if s1[i - 1] = s2[j - 1] then cost = 0, else cost = 1
+                    cost = (s1[i - 1] == s2[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[i - 1] == s2[j - 2]
+                            && s1[i - 2] == s2[j - 1]
+                        )
+                    {
+                        d[i, j] = Math.Min(d[i, j], d[i - 2, j - 2] + cost);
+                    }
+                }
+            }
+
+            return d[n, m];
+        }
+
+        private static int Min(int a, int b, int c) 
+            => Math.Min(a, Math.Min(b, c));
+    }
+}

src/F23.StringSimilarity/ShingleBased.cs

@@ -26,20 +26,25 @@ namespace F23.StringSimilarity
 {
     public abstract class ShingleBased
     {
-        public int k { get; }
+        private const int DEFAULT_K = 3;
+
+        /// <summary>
+        /// Return k, the length of k-shingles (aka n-grams).
+        /// </summary>
+        protected int k { get; }
 
         /// <summary>
         /// 
         /// </summary>
         /// <param name="k"></param>
-        public ShingleBased(int k)
+        protected ShingleBased(int k)
         {
             this.k = k;
         }
 
         /// <summary>
         /// 
         /// </summary>
-        public ShingleBased() : this(3) { }
+        protected ShingleBased() : this(DEFAULT_K) { }
     }
 }

src/F23.StringSimilarity/StringSet.cs

@@ -55,7 +55,7 @@ public double SorensenDiceSimilarity(StringSet other)
                 throw new Exception("Profiles were not created using the same kshingling object!");
             }
 
-            return 2 * _vector.Intersection(other._vector) / (_vector.Size + other._vector.Size);
+            return 2.0 * _vector.Intersection(other._vector) / (_vector.Size + other._vector.Size);
         }
     }
 }