From ebc0d3d309385831e3fd83a7a0da155c0ac2b27e Mon Sep 17 00:00:00 2001
From: Gilles Sadowski <erans@apache.org>
Date: Sun, 29 Jul 2012 12:12:11 +0000
Subject: [PATCH] Reverting changes inadvertently committed in revision
 1366821.

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@1366826 13f79535-47bb-0310-9956-ffa450edef68
---
 .../commons/math3/linear/LUDecomposition.java | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/src/main/java/org/apache/commons/math3/linear/LUDecomposition.java b/src/main/java/org/apache/commons/math3/linear/LUDecomposition.java
index a2a4be90c..65185d356 100644
--- a/src/main/java/org/apache/commons/math3/linear/LUDecomposition.java
+++ b/src/main/java/org/apache/commons/math3/linear/LUDecomposition.java
@@ -89,8 +89,8 @@ public class LUDecomposition {
                                                matrix.getColumnDimension());
         }
 
+        final int m = matrix.getColumnDimension();
         lu = matrix.getData();
-        final int m = lu.length;
         pivot = new int[m];
         cachedL = null;
         cachedU = null;
@@ -105,20 +105,15 @@ public class LUDecomposition {
 
         // Loop over columns
         for (int col = 0; col < m; col++) {
-            final double[] luColumnCol = new double[m];
-            for (int i = 0; i < m; i++) {
-                luColumnCol[i] = lu[i][col];
-            }
 
             // upper
             for (int row = 0; row < col; row++) {
                 final double[] luRow = lu[row];
                 double sum = luRow[col];
                 for (int i = 0; i < row; i++) {
-                    sum -= luRow[i] * luColumnCol[i];
+                    sum -= luRow[i] * lu[i][col];
                 }
                 luRow[col] = sum;
-                luColumnCol[row] = sum;
             }
 
             // lower
@@ -128,10 +123,9 @@ public class LUDecomposition {
                 final double[] luRow = lu[row];
                 double sum = luRow[col];
                 for (int i = 0; i < col; i++) {
-                    sum -= luRow[i] * luColumnCol[i];
+                    sum -= luRow[i] * lu[i][col];
                 }
                 luRow[col] = sum;
-                luColumnCol[row] = sum;
 
                 // maintain best permutation choice
                 if (FastMath.abs(sum) > largest) {
@@ -141,21 +135,22 @@ public class LUDecomposition {
             }
 
             // Singularity check
-            if (FastMath.abs(luColumnCol[max]) < singularityThreshold) {
+            if (FastMath.abs(lu[max][col]) < singularityThreshold) {
                 singular = true;
                 return;
             }
 
             // Pivot if necessary
             if (max != col) {
+                double tmp = 0;
                 final double[] luMax = lu[max];
                 final double[] luCol = lu[col];
                 for (int i = 0; i < m; i++) {
-                    final double tmp = luMax[i];
+                    tmp = luMax[i];
                     luMax[i] = luCol[i];
                     luCol[i] = tmp;
                 }
-                final int temp = pivot[max];
+                int temp = pivot[max];
                 pivot[max] = pivot[col];
                 pivot[col] = temp;
                 even = !even;