Mailing-List: contact commits-help@commons.apache.org; run by ezmlm
Precedence: bulk
Reply-To: dev@commons.apache.org
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Subject: svn commit: r1136516 -
 /commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/StringUtils.java
Date: Thu, 16 Jun 2011 16:11:20 -0000
To: commits@commons.apache.org
From: mbenson@apache.org
Message-Id: <20110616161120.BB54B2388A6C@eris.apache.org>

Author: mbenson
Date: Thu Jun 16 16:11:20 2011
New Revision: 1136516

URL: http://svn.apache.org/viewvc?rev=1136516&view=rev
Log:
ws only

Modified:
    commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/StringUtils.java

Modified: commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/StringUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/StringUtils.java?rev=1136516&r1=1136515&r2=1136516&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/StringUtils.java (original)
+++ commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/StringUtils.java Thu Jun 16 16:11:20 2011
@@ -6068,8 +6068,8 @@ public class StringUtils {
 
         /*
            The difference between this impl. and the previous is that, rather
-           than creating and retaining a matrix of size s.length()+1 by t.length()+1,
-           we maintain two single-dimensional arrays of length s.length()+1.  The first, d,
+           than creating and retaining a matrix of size s.length() + 1 by t.length() + 1,
+           we maintain two single-dimensional arrays of length s.length() + 1.  The first, d,
            is the 'current working' distance array that maintains the newest distance cost
            counts as we iterate through the characters of String s.  Each time we increment
            the index of String t we are comparing, d is copied to p, the second int[].  Doing so
@@ -6101,8 +6101,8 @@ public class StringUtils {
             m = t.length();
         }
 
-        int p[] = new int[n+1]; //'previous' cost array, horizontally
-        int d[] = new int[n+1]; // cost array, horizontally
+        int p[] = new int[n + 1]; //'previous' cost array, horizontally
+        int d[] = new int[n + 1]; // cost array, horizontally
         int _d[]; //placeholder to assist in swapping p and d
 
         // indexes into strings s and t
@@ -6113,18 +6113,18 @@ public class StringUtils {
 
         int cost; // cost
 
-        for (i = 0; i<=n; i++) {
+        for (i = 0; i <= n; i++) {
             p[i] = i;
         }
 
-        for (j = 1; j<=m; j++) {
-            t_j = t.charAt(j-1);
+        for (j = 1; j <= m; j++) {
+            t_j = t.charAt(j - 1);
             d[0] = j;
 
-            for (i=1; i<=n; i++) {
-                cost = s.charAt(i-1)==t_j ? 0 : 1;
+            for (i = 1; i <= n; i++) {
+                cost = s.charAt(i - 1) == t_j ? 0 : 1;
                 // minimum of cell to the left+1, to the top+1, diagonally left and up +cost
-                d[i] = Math.min(Math.min(d[i-1]+1, p[i]+1),  p[i-1]+cost);
+                d[i] = Math.min(Math.min(d[i - 1] + 1, p[i] + 1), p[i - 1] + cost);
             }
 
             // copy current distance counts to 'previous row' distance counts
@@ -6171,10 +6171,10 @@ public class StringUtils {
      * @throws IllegalArgumentException if either String input {@code null} or negative threshold
      */
     public static int getLevenshteinDistance(CharSequence s, CharSequence t, int threshold) {
-        if(s == null || t == null) {
+        if (s == null || t == null) {
             throw new IllegalArgumentException("Strings must not be null");
         }
-        if(threshold < 0) {
+        if (threshold < 0) {
             throw new IllegalArgumentException("Threshold must not be negative");
         }
 
@@ -6182,7 +6182,7 @@ public class StringUtils {
         This implementation only computes the distance if it's less than or equal to the
         threshold value, returning -1 if it's greater.  The advantage is performance: unbounded
         distance is O(nm), but a bound of k allows us to reduce it to O(km) time by only 
-        computing a diagonal stripe of width 2k+1 of the cost table.
+        computing a diagonal stripe of width 2k + 1 of the cost table.
         It is also possible to use this to compute the unbounded Levenshtein distance by starting
         the threshold at 1 and doubling each time until the distance is found; this is O(dm), where
         d is the distance.
@@ -6226,13 +6226,13 @@ public class StringUtils {
         int m = t.length(); // length of t
 
         // if one string is empty, the edit distance is necessarily the length of the other
-        if(n == 0) {
-            return m <= threshold? m : -1;
-        } else if(m == 0) {
-            return n <= threshold? n : -1;
+        if (n == 0) {
+            return m <= threshold ? m : -1;
+        } else if (m == 0) {
+            return n <= threshold ? n : -1;
         }
 
-        if(n > m) {
+        if (n > m) {
             // swap the two strings to consume less memory
             CharSequence tmp = s;
             s = t;
@@ -6241,13 +6241,13 @@ public class StringUtils {
             m = t.length();
         }
 
-        int p[] = new int[n+1]; // 'previous' cost array, horizontally
-        int d[] = new int[n+1]; // cost array, horizontally
+        int p[] = new int[n + 1]; // 'previous' cost array, horizontally
+        int d[] = new int[n + 1]; // cost array, horizontally
         int _d[]; // placeholder to assist in swapping p and d
 
         // fill in starting table values
         int boundary = Math.min(n, threshold) + 1;
-        for(int i = 0; i < boundary; i++) {
+        for (int i = 0; i < boundary; i++) {
             p[i] = i;
         }
         // these fills ensure that the value above the rightmost entry of our 
@@ -6256,8 +6256,8 @@ public class StringUtils {
         Arrays.fill(d, Integer.MAX_VALUE);
 
         // iterates through t
-        for(int j = 1; j <= m; j++) {
-            char t_j = t.charAt(j-1); // jth character of t
+        for (int j = 1; j <= m; j++) {
+            char t_j = t.charAt(j - 1); // jth character of t
             d[0] = j;
 
             // compute stripe indices, constrain to array size
@@ -6265,23 +6265,23 @@ public class StringUtils {
             int max = Math.min(n, j + threshold);
 
             // the stripe may lead off of the table if s and t are of different sizes
-            if(min > max) {
+            if (min > max) {
                 return -1;
             }
 
             // ignore entry left of leftmost
-            if(min > 1) {
-                d[min-1] = Integer.MAX_VALUE;
+            if (min > 1) {
+                d[min - 1] = Integer.MAX_VALUE;
             }
 
             // iterates through [min, max] in s
-            for(int i = min; i <= max; i++) {
-                if(s.charAt(i-1) == t_j) {
+            for (int i = min; i <= max; i++) {
+                if (s.charAt(i - 1) == t_j) {
                     // diagonally left and up
-                    d[i] = p[i-1];
+                    d[i] = p[i - 1];
                 } else {
                     // 1 + minimum of cell to the left, to the top, diagonally left and up
-                    d[i] = 1 + Math.min(Math.min(d[i-1], p[i]), p[i-1]);
+                    d[i] = 1 + Math.min(Math.min(d[i - 1], p[i]), p[i - 1]);
                 }
             }
 
@@ -6293,7 +6293,7 @@ public class StringUtils {
 
         // if p[n] is greater than the threshold, there's no guarantee on it being the correct
         // distance
-        if(p[n] <= threshold) {
+        if (p[n] <= threshold) {
             return p[n];
         } else {
             return -1;