sis-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From desruisse...@apache.org
Subject svn commit: r1528873 - /sis/branches/JDK7/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java
Date Thu, 03 Oct 2013 14:06:02 GMT
Author: desruisseaux
Date: Thu Oct  3 14:06:01 2013
New Revision: 1528873

URL: http://svn.apache.org/r1528873
Log:
Post double-double arithmetic cleaning: trivial renaming of local variables for more clarity.

Modified:
    sis/branches/JDK7/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java

Modified: sis/branches/JDK7/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java
URL: http://svn.apache.org/viewvc/sis/branches/JDK7/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java?rev=1528873&r1=1528872&r2=1528873&view=diff
==============================================================================
--- sis/branches/JDK7/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java
[UTF-8] (original)
+++ sis/branches/JDK7/core/sis-referencing/src/main/java/org/apache/sis/referencing/operation/matrix/Solver.java
[UTF-8] Thu Oct  3 14:06:01 2013
@@ -161,8 +161,8 @@ final class Solver implements Matrix {
            pivot[j] = j;
         }
         final double[]  column = new double[size * 2]; // [0 … size-1] : column values;
[size … 2*size-1] : error terms.
-        final DoubleDouble tmp = new DoubleDouble();
-        final DoubleDouble sum = new DoubleDouble();
+        final DoubleDouble acc = new DoubleDouble();   // Temporary variable for sum ("accumulator")
and subtraction.
+        final DoubleDouble rat = new DoubleDouble();   // Temporary variable for products
and ratios.
         for (int i=0; i<size; i++) {
             /*
              * Make a copy of the i-th column.
@@ -185,16 +185,16 @@ final class Solver implements Matrix {
             for (int j=0; j<size; j++) {
                 final int rowOffset = j*size;
                 final int kmax = Math.min(j,i);
-                sum.clear();
+                acc.clear();
                 for (int k=0; k<kmax; k++) {
-                    tmp.setFrom(LU, rowOffset + k, errorLU);
-                    tmp.multiply(column, k, size);
-                    sum.add(tmp);
-                }
-                sum.subtract(column, j, size);
-                sum.negate();
-                sum.storeTo(column, j, size);
-                sum.storeTo(LU, rowOffset + i, errorLU);
+                    rat.setFrom(LU, rowOffset + k, errorLU);
+                    rat.multiply(column, k, size);
+                    acc.add(rat);
+                }
+                acc.subtract(column, j, size);
+                acc.negate();
+                acc.storeTo(column, j, size);
+                acc.storeTo(LU, rowOffset + i, errorLU);
             }
             /*
              * Find pivot and exchange if necessary. There is no floating-point arithmetic
here
@@ -225,13 +225,13 @@ final class Solver implements Matrix {
              *         }
              *     }
              */
-            sum.setFrom(LU, i*size + i, errorLU);
-            if (!sum.isZero()) {
+            acc.setFrom(LU, i*size + i, errorLU);
+            if (!acc.isZero()) {
                 for (int j=i; ++j < size;) {
                     final int t = j*size + i;
-                    tmp.setFrom(sum);
-                    tmp.inverseDivide(LU, t, errorLU);
-                    tmp.storeTo      (LU, t, errorLU);
+                    rat.setFrom(acc);
+                    rat.inverseDivide(LU, t, errorLU);
+                    rat.storeTo      (LU, t, errorLU);
                 }
             }
         }
@@ -240,8 +240,8 @@ final class Solver implements Matrix {
          * Ensure that the matrix is not singular.
          */
         for (int j=0; j<size; j++) {
-            tmp.setFrom(LU, j*size + j, errorLU);
-            if (tmp.isZero()) {
+            rat.setFrom(LU, j*size + j, errorLU);
+            if (rat.isZero()) {
                 throw new NoninvertibleMatrixException();
             }
         }
@@ -277,11 +277,11 @@ final class Solver implements Matrix {
                 final int loRowOffset = j*innerSize;    // Offset of some row after the current
row.
                 final int luRowOffset = j*size;         // Offset of the corresponding row
in the LU matrix.
                 for (int i=0; i<innerSize; i++) {
-                    sum.setFrom (elements, loRowOffset + i, errorOffset);
-                    tmp.setFrom (elements, rowOffset   + i, errorOffset);
-                    tmp.multiply(LU,       luRowOffset + k, errorLU);
-                    sum.subtract(tmp);
-                    sum.storeTo (elements, loRowOffset + i, errorOffset);
+                    acc.setFrom (elements, loRowOffset + i, errorOffset);
+                    rat.setFrom (elements, rowOffset   + i, errorOffset);
+                    rat.multiply(LU,       luRowOffset + k, errorLU);
+                    acc.subtract(rat);
+                    acc.storeTo (elements, loRowOffset + i, errorOffset);
                 }
             }
         }
@@ -302,21 +302,21 @@ final class Solver implements Matrix {
          */
         for (int k=size; --k >= 0;) {
             final int rowOffset = k*innerSize;          // Offset of row computed by current
iteration.
-            sum.setFrom(LU, k*size + k, errorLU);       // A diagonal element on the current
row.
+            acc.setFrom(LU, k*size + k, errorLU);       // A diagonal element on the current
row.
             for (int i=0; i<innerSize; i++) {           // Apply to all columns in the
current row.
-                tmp.setFrom(sum);
-                tmp.inverseDivide(elements, rowOffset + i, errorOffset);
-                tmp.storeTo      (elements, rowOffset + i, errorOffset);
+                rat.setFrom(acc);
+                rat.inverseDivide(elements, rowOffset + i, errorOffset);
+                rat.storeTo      (elements, rowOffset + i, errorOffset);
             }
             for (int j=0; j<k; j++) {
                 final int upRowOffset = j*innerSize;    // Offset of a row before (locate
upper) the current row.
-                sum.setFrom(LU, j*size + k, errorLU);   // Same column than the diagonal
element, but in the upper row.
+                acc.setFrom(LU, j*size + k, errorLU);   // Same column than the diagonal
element, but in the upper row.
                 for (int i=0; i<innerSize; i++) {       // Apply to all columns in the
upper row.
-                    tmp.setFrom(elements, rowOffset + i, errorOffset);
-                    tmp.multiply(sum);
-                    tmp.subtract(elements, upRowOffset + i, errorOffset);
-                    tmp.negate();
-                    tmp.storeTo(elements, upRowOffset + i, errorOffset);
+                    rat.setFrom(elements, rowOffset + i, errorOffset);
+                    rat.multiply(acc);
+                    rat.subtract(elements, upRowOffset + i, errorOffset);
+                    rat.negate();
+                    rat.storeTo(elements, upRowOffset + i, errorOffset);
                 }
             }
         }



Mime
View raw message