Added checkstyle test + removed sparse vector classes, which not used anymore

Author: tdebatty

pom.xml

@@ -22,7 +22,7 @@
             <url>http://www.opensource.org/licenses/mit-license.php</url>
         </license>
     </licenses>
-    
+
     <developers>
         <developer>
             <name>Thibault Debatty</name>
@@ -31,7 +31,7 @@
             <organizationUrl>http://debatty.info</organizationUrl>
         </developer>
     </developers>
-    
+
     <scm>
         <connection>scm:git:git@github.com:tdebatty/java-string-similarity.git</connection>
         <developerConnection>scm:git:git@github.com:tdebatty/java-string-similarity.git</developerConnection>
@@ -156,6 +156,29 @@
                     </instrumentation>
                 </configuration>
             </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-checkstyle-plugin</artifactId>
+                <version>2.16</version>
+                <executions>
+                    <execution>
+                        <id>validate</id>
+                        <phase>verify</phase>
+                        <configuration>
+                            <configLocation>checkstyle.xml</configLocation>
+                            <cacheFile>target/checkstyle_cache</cacheFile>
+                            <encoding>UTF-8</encoding>
+                            <consoleOutput>true</consoleOutput>
+                            <linkXRef>false</linkXRef>
+                            <excludes>**/examples/**</excludes>
+                        </configuration>
+                        <goals>
+                            <goal>check</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 

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

@@ -56,15 +56,15 @@ public Cosine(final int 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.
-     * Default k is 3.
+     * strings is the cosine of their respective vectors. Default k is 3.
      */
     public Cosine() {
         super();
     }
 
     /**
      * Compute the cosine similarity between strings.
+     *
      * @param s1 The first string to compare.
      * @param s2 The second string to compare.
      * @return The cosine similarity in the range [0, 1]
@@ -94,8 +94,6 @@ public final double similarity(final String s1, final String s2) {
                 / (norm(profile1) * norm(profile2));
     }
 
-
-
     /**
      * Compute the norm L2 : sqrt(Sum_i( v_i²)).
      *
@@ -126,8 +124,8 @@ private static double dotProduct(
 
         double agg = 0;
         for (Map.Entry<String, Integer> entry : small_profile.entrySet()) {
-        	Integer i=large_profile.get(entry.getKey());
-            if (i==null) {
+            Integer i = large_profile.get(entry.getKey());
+            if (i == null) {
                 continue;
             }
             agg += 1.0 * entry.getValue() * i;
@@ -138,6 +136,7 @@ private static double dotProduct(
 
     /**
      * Return 1.0 - similarity.
+     *
      * @param s1 The first string to compare.
      * @param s2 The second string to compare.
      * @return 1.0 - the cosine similarity in the range [0, 1]
@@ -147,7 +146,13 @@ public final double distance(final String s1, final String s2) {
         return 1.0 - similarity(s1, s2);
     }
 
-    public double similarity(
+    /**
+     * {@inheritDoc}
+     * @param profile1
+     * @param profile2
+     * @return
+     */
+    public final double similarity(
             final Map<String, Integer> profile1,
             final Map<String, Integer> profile2) {
 

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

@@ -111,17 +111,19 @@ private int[] matches(final String s1, final String s2) {
             min = s1;
         }
         int range = Math.max(max.length() / 2 - 1, 0);
-        int[] matchIndexes = new int[min.length()];
-        Arrays.fill(matchIndexes, -1);
-        boolean[] matchFlags = new boolean[max.length()];
+        int[] match_indexes = new int[min.length()];
+        Arrays.fill(match_indexes, -1);
+        boolean[] match_flags = new boolean[max.length()];
         int matches = 0;
         for (int mi = 0; mi < min.length(); mi++) {
             char c1 = min.charAt(mi);
             for (int xi = Math.max(mi - range, 0),
-                    xn = Math.min(mi + range + 1, max.length()); xi < xn; xi++) {
-                if (!matchFlags[xi] && c1 == max.charAt(xi)) {
-                    matchIndexes[mi] = xi;
-                    matchFlags[xi] = true;
+                    xn = Math.min(mi + range + 1, max.length());
+                    xi < xn;
+                    xi++) {
+                if (!match_flags[xi] && c1 == max.charAt(xi)) {
+                    match_indexes[mi] = xi;
+                    match_flags[xi] = true;
                     matches++;
                     break;
                 }
@@ -130,13 +132,13 @@ private int[] matches(final String s1, final String s2) {
         char[] ms1 = new char[matches];
         char[] ms2 = new char[matches];
         for (int i = 0, si = 0; i < min.length(); i++) {
-            if (matchIndexes[i] != -1) {
+            if (match_indexes[i] != -1) {
                 ms1[si] = min.charAt(i);
                 si++;
             }
         }
         for (int i = 0, si = 0; i < max.length(); i++) {
-            if (matchFlags[i]) {
+            if (match_flags[i]) {
                 ms2[si] = max.charAt(i);
                 si++;
             }

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

@@ -87,15 +87,15 @@ public final int length(final String s1, final String s2) {
          C[i,j] := max(C[i,j-1], C[i-1,j])
          return C[m,n]
          */
-        int m = s1.length();
-        int n = s2.length();
+        int s1_length = s1.length();
+        int s2_length = s2.length();
         char[] x = s1.toCharArray();
         char[] y = s2.toCharArray();
 
-        int[][] c = new int[m + 1][n + 1];
+        int[][] c = new int[s1_length + 1][s2_length + 1];
 
-        for (int i = 1; i <= m; i++) {
-            for (int j = 1; j <= n; j++) {
+        for (int i = 1; i <= s1_length; i++) {
+            for (int j = 1; j <= s2_length; j++) {
                 if (x[i - 1] == y[j - 1]) {
                     c[i][j] = c[i - 1][j - 1] + 1;
 
@@ -105,6 +105,6 @@ public final int length(final String s1, final String s2) {
             }
         }
 
-        return c[m][n];
+        return c[s1_length][s2_length];
     }
 }

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

@@ -62,12 +62,12 @@ public final double distance(final String s1, final String s2) {
             return 0;
         }
 
-        int mLen = Math.max(s1.length(), s2.length());
-        if (mLen == 0) {
+        int m_len = Math.max(s1.length(), s2.length());
+        if (m_len == 0) {
             return 0;
         }
         return 1.0
             - (1.0 * lcs.length(s1, s2))
-            / mLen;
+            / m_len;
     }
 }

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

@@ -62,13 +62,13 @@ public final double distance(final String s1, final String s2) {
             return 0;
         }
 
-        int mLen = Math.max(s1.length(), s2.length());
+        int m_len = Math.max(s1.length(), s2.length());
 
-        if (mLen == 0) {
+        if (m_len == 0) {
             return 0;
         }
 
-        return l.distance(s1, s2) / mLen;
+        return l.distance(s1, s2) / m_len;
     }
 
     /**

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

@@ -51,7 +51,7 @@ public final class OptimalStringAlignment implements StringDistance {
      * @return the OSA distance
      * @throws NullPointerException if s1 or s2 is null.
      */
-    public final double distance(final String s1, final String s2) {
+    public double distance(final String s1, final String s2) {
         if (s1 == null) {
             throw new NullPointerException("s1 must not be null");
         }
@@ -92,19 +92,21 @@ public final double distance(final String s1, final String s2) {
             for (int j = 1; j <= m; 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;
+                cost = 1;
+                if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
+                    cost = 0;
+                }
 
                 d[i][j] = min(
                         d[i - 1][j - 1] + cost, // substitution
-                        d[i][j - 1] + 1,        // insertion
-                        d[i - 1][j] + 1         // deletion
+                        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)
-                    ){
+                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);
                 }
             }

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

@@ -44,9 +44,9 @@
  * replaced by a single space, and a k-gram is a sequence of k characters.
  *
  * Default value of k is 3. A good rule of thumb is to imagine that there are
- * only 20 characters and estimate the number of k-shingles as 20^k. For
- * small documents like e-mails, k = 5 is a recommended value. For large
- * documents, such as research articles, k = 9 is considered a safe choice.
+ * only 20 characters and estimate the number of k-shingles as 20^k. For small
+ * documents like e-mails, k = 5 is a recommended value. For large documents,
+ * such as research articles, k = 9 is considered a safe choice.
  *
  * @author Thibault Debatty
  */
@@ -93,11 +93,10 @@ public int getK() {
     /**
      * Compute and return the profile of s, as defined by Ukkonen "Approximate
      * string-matching with q-grams and maximal matches".
-     * https://www.cs.helsinki.fi/u/ukkonen/TCS92.pdf
-     * The profile is the number of occurrences of k-shingles, and is used to
-     * compute q-gram similarity, Jaccard index, etc.
-     * Pay attention: the memory requirement of the profile can be up to
-     * k * size of the string
+     * https://www.cs.helsinki.fi/u/ukkonen/TCS92.pdf The profile is the number
+     * of occurrences of k-shingles, and is used to compute q-gram similarity,
+     * Jaccard index, etc. Pay attention: the memory requirement of the profile
+     * can be up to k * size of the string
      *
      * @param string
      * @return the profile of this string, as an unmodifiable Map
@@ -109,7 +108,7 @@ public final Map<String, Integer> getProfile(final String string) {
         for (int i = 0; i < (string_no_space.length() - k + 1); i++) {
             String shingle = string_no_space.substring(i, i + k);
             Integer old = shingles.get(shingle);
-            if (old!=null) {
+            if (old != null) {
                 shingles.put(shingle, old + 1);
             } else {
                 shingles.put(shingle, 1);

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

@@ -63,15 +63,15 @@ public SorensenDice(final int k) {
      * The strings are first converted to boolean sets of k-shingles (sequences
      * of k characters), then the similarity is computed as 2 * |A inter B| /
      * (|A| + |B|). Attention: Sorensen-Dice distance (and similarity) does not
-     * satisfy triangle inequality.
-     * Default k is 3.
+     * satisfy triangle inequality. Default k is 3.
      */
     public SorensenDice() {
         super();
     }
 
     /**
      * Similarity is computed as 2 * |A inter B| / (|A| + |B|).
+     *
      * @param s1 The first string to compare.
      * @param s2 The second string to compare.
      * @return The computed Sorensen-Dice similarity.
@@ -108,15 +108,15 @@ public final double similarity(final String s1, final String s2) {
         return 2.0 * inter / (profile1.size() + profile2.size());
     }
 
-
     /**
      * Returns 1 - similarity.
+     *
      * @param s1 The first string to compare.
      * @param s2 The second string to compare.
      * @return 1.0 - the computed similarity
      * @throws NullPointerException if s1 or s2 is null.
      */
-    public double distance(String s1, String s2) {
+    public final double distance(final String s1, final String s2) {
         return 1 - similarity(s1, s2);
     }
 }