commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pste...@apache.org
Subject svn commit: r1097918 - in /commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear: CholeskyDecompositionImpl.java EigenDecompositionImpl.java
Date Fri, 29 Apr 2011 19:08:09 GMT
Author: psteitz
Date: Fri Apr 29 19:08:09 2011
New Revision: 1097918

URL: http://svn.apache.org/viewvc?rev=1097918&view=rev
Log:
Reuse is one word :).

Modified:
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/CholeskyDecompositionImpl.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/EigenDecompositionImpl.java

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/CholeskyDecompositionImpl.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/CholeskyDecompositionImpl.java?rev=1097918&r1=1097917&r2=1097918&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/CholeskyDecompositionImpl.java
(original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/CholeskyDecompositionImpl.java
Fri Apr 29 19:08:09 2011
@@ -277,7 +277,7 @@ public class CholeskyDecompositionImpl i
          * <p>The A matrix is implicit, it is provided by the underlying
          * decomposition algorithm.</p>
          * @param b right-hand side of the equation A &times; X = B
-         * @param reUseB if true, the b array will be reused and returned,
+         * @param reuseB if true, the b array will be reused and returned,
          * instead of being copied
          * @return a matrix X that minimizes the two norm of A &times; X - B
          * @throws org.apache.commons.math.exception.DimensionMismatchException
@@ -285,7 +285,7 @@ public class CholeskyDecompositionImpl i
          * @throws SingularMatrixException
          * if the decomposed matrix is singular.
          */
-        private double[][] solve(double[][] b, boolean reUseB) {
+        private double[][] solve(double[][] b, boolean reuseB) {
             final int m = lTData.length;
             if (b.length != m) {
                 throw new DimensionMismatchException(b.length, m);
@@ -293,7 +293,7 @@ public class CholeskyDecompositionImpl i
 
             final int nColB = b[0].length;
             final double[][] x;
-            if (reUseB) {
+            if (reuseB) {
                 x = b;
             } else {
                 x = new double[b.length][nColB];

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/EigenDecompositionImpl.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/EigenDecompositionImpl.java?rev=1097918&r1=1097917&r2=1097918&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/EigenDecompositionImpl.java
(original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/EigenDecompositionImpl.java
Fri Apr 29 19:08:09 2011
@@ -342,7 +342,7 @@ public class EigenDecompositionImpl impl
          * <p>The A matrix is implicit, it is provided by the underlying
          * decomposition algorithm.</p>
          * @param b right-hand side of the equation A &times; X = B
-         * @param reUseB if true, the b array will be reused and returned,
+         * @param reuseB if true, the b array will be reused and returned,
          * instead of being copied
          * @return a matrix X that minimizes the two norm of A &times; X - B
          * @throws org.apache.commons.math.exception.DimensionMismatchException
@@ -350,7 +350,7 @@ public class EigenDecompositionImpl impl
          * @throws SingularMatrixException
          * if the decomposed matrix is singular.
          */
-        private double[][] solve(double[][] b, boolean reUseB) {
+        private double[][] solve(double[][] b, boolean reuseB) {
 
             if (!isNonSingular()) {
                 throw new SingularMatrixException();
@@ -363,7 +363,7 @@ public class EigenDecompositionImpl impl
 
             final int nColB = b[0].length;
             final double[][] bp;
-            if (reUseB) {
+            if (reuseB) {
                 bp = b;
             } else {
                 bp = new double[m][nColB];



Mime
View raw message