commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From l..@apache.org
Subject svn commit: r662241 [1/2] - in /commons/proper/math/branches/MATH_2_0/src: java/org/apache/commons/math/linear/ site/xdoc/ test/org/apache/commons/math/linear/
Date Sun, 01 Jun 2008 16:22:20 GMT
Author: luc
Date: Sun Jun  1 09:22:19 2008
New Revision: 662241

URL: http://svn.apache.org/viewvc?rev=662241&view=rev
Log:
Improved linear RealMatrixImpl and BigMatrixImpl performances.
The main changes are the following ones:
 - use directly the storage array when possible for
   diadic operations (add, subtract, multiply), as
   suggested by Phil, this avoids the cost of the
   generic getEntry method
 - replaced custom indices checks by simple use of
   the JVM checks and ArrayIndexOutOfBoundException
 - put row arrays reference in local variables to
   avoid multiple checks in double loops
 - use final variables where possible
 - removed unneeded array copying
 - added a constructor to build a matrix from an
   array without copying it where it makes sense

The speed gain is about 3X for multiplication. Performances
for this operation are now on par with Jama.

Modified:
    commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/BigMatrixImpl.java
    commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/MatrixUtils.java
    commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealMatrixImpl.java
    commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml
    commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/BigMatrixImplTest.java
    commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/MatrixUtilsTest.java
    commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/QRDecompositionImplTest.java
    commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/RealMatrixImplTest.java

Modified: commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/BigMatrixImpl.java
URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/BigMatrixImpl.java?rev=662241&r1=662240&r2=662241&view=diff
==============================================================================
--- commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/BigMatrixImpl.java (original)
+++ commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/BigMatrixImpl.java Sun Jun  1 09:22:19 2008
@@ -106,8 +106,9 @@
     /**
      * Create a new BigMatrix using <code>d</code> as the underlying
      * data array.
-     * <p>
-     * The input array is copied, not referenced.</p>
+     * <p>The input array is copied, not referenced. This constructor has
+     * the same effect as calling {@link #BigMatrixImpl(BigDecimal[][], boolean)}
+     * with the second argument set to <code>true</code>.</p>
      *
      * @param d data for new matrix
      * @throws IllegalArgumentException if <code>d</code> is not rectangular
@@ -118,12 +119,52 @@
         this.copyIn(d);
         lu = null;
     }
-    
+
+    /**
+     * Create a new BigMatrix using the input array as the underlying
+     * data array.
+     * <p>If an array is built specially in order to be embedded in a
+     * BigMatrix and not used directly, the <code>copyArray</code> may be
+     * set to <code>false</code. This will prevent the copying and improve
+     * performance as no new array will be built and no data will be copied.</p>
+     * @param d data for new matrix
+     * @param copyArray if true, the input array will be copied, otherwise
+     * it will be referenced
+     * @throws IllegalArgumentException if <code>d</code> is not rectangular
+     *  (not all rows have the same length) or empty
+     * @throws NullPointerException if <code>d</code> is null
+     * @see #BigMatrix(BigDecimal[][])
+     */
+    public BigMatrixImpl(BigDecimal[][] d, boolean copyArray) {
+        if (copyArray) {
+            copyIn(d);
+        } else {
+            if (d == null) {
+                throw new NullPointerException();
+            }   
+            final int nRows = d.length;
+            if (nRows == 0) {
+                throw new IllegalArgumentException("Matrix must have at least one row."); 
+            }
+            final int nCols = d[0].length;
+            if (nCols == 0) {
+                throw new IllegalArgumentException("Matrix must have at least one column."); 
+            }
+            for (int r = 1; r < nRows; r++) {
+                if (d[r].length != nCols) {
+                    throw new IllegalArgumentException("All input rows must have the same length.");
+                }
+            }       
+            data = d;
+        }
+        lu = null;
+    }
+
     /**
      * Create a new BigMatrix using <code>d</code> as the underlying
      * data array.
-     * <p>
-     * The input array is copied, not referenced.</p>
+     * <p>Since the underlying array will hold <code>BigDecimal</code>
+     * instances, it will be created.</p>
      *
      * @param d data for new matrix
      * @throws IllegalArgumentException if <code>d</code> is not rectangular
@@ -131,12 +172,12 @@
      * @throws NullPointerException if <code>d</code> is null
      */
     public BigMatrixImpl(double[][] d) {
-        int nRows = d.length;
+        final int nRows = d.length;
         if (nRows == 0) {
             throw new IllegalArgumentException(
             "Matrix must have at least one row."); 
         }
-        int nCols = d[0].length;
+        final int nCols = d[0].length;
         if (nCols == 0) {
             throw new IllegalArgumentException(
             "Matrix must have at least one column."); 
@@ -161,12 +202,12 @@
      * @throws NullPointerException if <code>d</code> is null
      */
     public BigMatrixImpl(String[][] d) {
-        int nRows = d.length;
+        final int nRows = d.length;
         if (nRows == 0) {
             throw new IllegalArgumentException(
             "Matrix must have at least one row."); 
         }
-        int nCols = d[0].length;
+        final int nCols = d[0].length;
         if (nCols == 0) {
             throw new IllegalArgumentException(
             "Matrix must have at least one column."); 
@@ -191,7 +232,7 @@
      * @param v column vector holding data for new matrix
      */
     public BigMatrixImpl(BigDecimal[] v) {
-        int nRows = v.length;
+        final int nRows = v.length;
         data = new BigDecimal[nRows][1];
         for (int row = 0; row < nRows; row++) {
             data[row][0] = v[row];
@@ -204,7 +245,7 @@
      * @return  the cloned matrix
      */
     public BigMatrix copy() {
-        return new BigMatrixImpl(this.copyOut());
+        return new BigMatrixImpl(this.copyOut(), false);
     }
     
     /**
@@ -212,47 +253,107 @@
      *
      * @param m    matrix to be added
      * @return     this + m
-     * @exception  IllegalArgumentException if m is not the same size as this
+     * @throws  IllegalArgumentException if m is not the same size as this
      */
     public BigMatrix add(BigMatrix m) throws IllegalArgumentException {
-        if (this.getColumnDimension() != m.getColumnDimension() ||
-                this.getRowDimension() != m.getRowDimension()) {
+        try {
+            return add((BigMatrixImpl) m);
+        } catch (ClassCastException cce) {
+            final int rowCount    = getRowDimension();
+            final int columnCount = getColumnDimension();
+            if (columnCount != m.getColumnDimension() || rowCount != m.getRowDimension()) {
+                throw new IllegalArgumentException("matrix dimension mismatch");
+            }
+            final BigDecimal[][] outData = new BigDecimal[rowCount][columnCount];
+            for (int row = 0; row < rowCount; row++) {
+                final BigDecimal[] dataRow    = data[row];
+                final BigDecimal[] outDataRow = outData[row];
+                for (int col = 0; col < columnCount; col++) {
+                    outDataRow[col] = dataRow[col].add(m.getEntry(row, col));
+                }  
+            }
+            return new BigMatrixImpl(outData, false);
+        }
+    }
+
+    /**
+     * Compute the sum of this and <code>m</code>.
+     *
+     * @param m    matrix to be added
+     * @return     this + m
+     * @throws  IllegalArgumentException if m is not the same size as this
+     */
+    public BigMatrixImpl add(BigMatrixImpl m) throws IllegalArgumentException {
+        final int rowCount    = getRowDimension();
+        final int columnCount = getColumnDimension();
+        if (columnCount != m.getColumnDimension() || rowCount != m.getRowDimension()) {
             throw new IllegalArgumentException("matrix dimension mismatch");
         }
-        int rowCount = this.getRowDimension();
-        int columnCount = this.getColumnDimension();
-        BigDecimal[][] outData = new BigDecimal[rowCount][columnCount];
+        final BigDecimal[][] outData = new BigDecimal[rowCount][columnCount];
         for (int row = 0; row < rowCount; row++) {
+            final BigDecimal[] dataRow    = data[row];
+            final BigDecimal[] mRow       = m.data[row];
+            final BigDecimal[] outDataRow = outData[row];
             for (int col = 0; col < columnCount; col++) {
-                outData[row][col] = data[row][col].add(m.getEntry(row, col));
-            }
+                outDataRow[col] = dataRow[col].add(mRow[col]);
+            }  
         }
-        return new BigMatrixImpl(outData);
+        return new BigMatrixImpl(outData, false);
     }
-    
+
     /**
      * Compute  this minus <code>m</code>.
      *
      * @param m    matrix to be subtracted
      * @return     this + m
-     * @exception  IllegalArgumentException if m is not the same size as *this
+     * @throws  IllegalArgumentException if m is not the same size as this
      */
     public BigMatrix subtract(BigMatrix m) throws IllegalArgumentException {
-        if (this.getColumnDimension() != m.getColumnDimension() ||
-                this.getRowDimension() != m.getRowDimension()) {
+        try {
+            return subtract((BigMatrixImpl) m);
+        } catch (ClassCastException cce) {
+            final int rowCount    = getRowDimension();
+            final int columnCount = getColumnDimension();
+            if (columnCount != m.getColumnDimension() || rowCount != m.getRowDimension()) {
+                throw new IllegalArgumentException("matrix dimension mismatch");
+            }
+            final BigDecimal[][] outData = new BigDecimal[rowCount][columnCount];
+            for (int row = 0; row < rowCount; row++) {
+                final BigDecimal[] dataRow    = data[row];
+                final BigDecimal[] outDataRow = outData[row];
+                for (int col = 0; col < columnCount; col++) {
+                    outDataRow[col] = dataRow[col].subtract(getEntry(row, col));
+                }  
+            }
+            return new BigMatrixImpl(outData, false);
+        }
+    }
+
+    /**
+     * Compute  this minus <code>m</code>.
+     *
+     * @param m    matrix to be subtracted
+     * @return     this + m
+     * @throws  IllegalArgumentException if m is not the same size as this
+     */
+    public BigMatrixImpl subtract(BigMatrixImpl m) throws IllegalArgumentException {
+        final int rowCount    = getRowDimension();
+        final int columnCount = getColumnDimension();
+        if (columnCount != m.getColumnDimension() || rowCount != m.getRowDimension()) {
             throw new IllegalArgumentException("matrix dimension mismatch");
         }
-        int rowCount = this.getRowDimension();
-        int columnCount = this.getColumnDimension();
-        BigDecimal[][] outData = new BigDecimal[rowCount][columnCount];
+        final BigDecimal[][] outData = new BigDecimal[rowCount][columnCount];
         for (int row = 0; row < rowCount; row++) {
+            final BigDecimal[] dataRow    = data[row];
+            final BigDecimal[] mRow       = m.data[row];
+            final BigDecimal[] outDataRow = outData[row];
             for (int col = 0; col < columnCount; col++) {
-                outData[row][col] = data[row][col].subtract(m.getEntry(row, col));
-            }
+                outDataRow[col] = dataRow[col].subtract(mRow[col]);
+            }  
         }
-        return new BigMatrixImpl(outData);
+        return new BigMatrixImpl(outData, false);
     }
-    
+
     /**
      * Returns the result of adding d to each entry of this.
      *
@@ -260,34 +361,38 @@
      * @return     d + this
      */
     public BigMatrix scalarAdd(BigDecimal d) {
-        int rowCount = this.getRowDimension();
-        int columnCount = this.getColumnDimension();
-        BigDecimal[][] outData = new BigDecimal[rowCount][columnCount];
+        final int rowCount    = getRowDimension();
+        final int columnCount = getColumnDimension();
+        final BigDecimal[][] outData = new BigDecimal[rowCount][columnCount];
         for (int row = 0; row < rowCount; row++) {
+            final BigDecimal[] dataRow    = data[row];
+            final BigDecimal[] outDataRow = outData[row];
             for (int col = 0; col < columnCount; col++) {
-                outData[row][col] = data[row][col].add(d);
+                outDataRow[col] = dataRow[col].add(d);
             }
         }
-        return new BigMatrixImpl(outData);
+        return new BigMatrixImpl(outData, false);
     }
-    
+
     /**
-     * Returns the result multiplying each entry of this by <code>d</code>
+     * Returns the result of multiplying each entry of this by <code>d</code>
      * @param d  value to multiply all entries by
      * @return d * this
      */
     public BigMatrix scalarMultiply(BigDecimal d) {
-        int rowCount = this.getRowDimension();
-        int columnCount = this.getColumnDimension();
-        BigDecimal[][] outData = new BigDecimal[rowCount][columnCount];
+        final int rowCount    = getRowDimension();
+        final int columnCount = getColumnDimension();
+        final BigDecimal[][] outData = new BigDecimal[rowCount][columnCount];
         for (int row = 0; row < rowCount; row++) {
+            final BigDecimal[] dataRow    = data[row];
+            final BigDecimal[] outDataRow = outData[row];
             for (int col = 0; col < columnCount; col++) {
-                outData[row][col] = data[row][col].multiply(d);
+                outDataRow[col] = dataRow[col].multiply(d);
             }
         }
-        return new BigMatrixImpl(outData);
+        return new BigMatrixImpl(outData, false);
     }
-    
+
     /**
      * Returns the result of postmultiplying this by <code>m</code>.
      * @param m    matrix to postmultiply by
@@ -296,26 +401,60 @@
      *             if columnDimension(this) != rowDimension(m)
      */
     public BigMatrix multiply(BigMatrix m) throws IllegalArgumentException {
+        try {
+            return multiply((BigMatrixImpl) m);
+        } catch (ClassCastException cce) {
+            if (this.getColumnDimension() != m.getRowDimension()) {
+                throw new IllegalArgumentException("Matrices are not multiplication compatible.");
+            }
+            final int nRows = this.getRowDimension();
+            final int nCols = m.getColumnDimension();
+            final int nSum = this.getColumnDimension();
+            final BigDecimal[][] outData = new BigDecimal[nRows][nCols];
+            for (int row = 0; row < nRows; row++) {
+                final BigDecimal[] dataRow    = data[row];
+                final BigDecimal[] outDataRow = outData[row];
+                for (int col = 0; col < nCols; col++) {
+                    BigDecimal sum = ZERO;
+                    for (int i = 0; i < nSum; i++) {
+                        sum = sum.add(dataRow[i].multiply(m.getEntry(i, col)));
+                    }
+                    outDataRow[col] = sum;
+                }
+            }
+            return new BigMatrixImpl(outData, false);
+        }
+    }
+
+    /**
+     * Returns the result of postmultiplying this by <code>m</code>.
+     * @param m    matrix to postmultiply by
+     * @return     this*m
+     * @throws     IllegalArgumentException
+     *             if columnDimension(this) != rowDimension(m)
+     */
+    public BigMatrixImpl multiply(BigMatrixImpl m) throws IllegalArgumentException {
         if (this.getColumnDimension() != m.getRowDimension()) {
             throw new IllegalArgumentException("Matrices are not multiplication compatible.");
         }
-        int nRows = this.getRowDimension();
-        int nCols = m.getColumnDimension();
-        int nSum = this.getColumnDimension();
-        BigDecimal[][] outData = new BigDecimal[nRows][nCols];
-        BigDecimal sum = ZERO;
+        final int nRows = this.getRowDimension();
+        final int nCols = m.getColumnDimension();
+        final int nSum = this.getColumnDimension();
+        final BigDecimal[][] outData = new BigDecimal[nRows][nCols];
         for (int row = 0; row < nRows; row++) {
+            final BigDecimal[] dataRow    = data[row];
+            final BigDecimal[] outDataRow = outData[row];
             for (int col = 0; col < nCols; col++) {
-                sum = ZERO;
+                BigDecimal sum = ZERO;
                 for (int i = 0; i < nSum; i++) {
-                    sum = sum.add(data[row][i].multiply(m.getEntry(i, col)));
+                    sum = sum.add(dataRow[i].multiply(m.data[i][col]));
                 }
-                outData[row][col] = sum;
+                outDataRow[col] = sum;
             }
-        }
-        return new BigMatrixImpl(outData);
+        }            
+        return new BigMatrixImpl(outData, false);
     }
-    
+
     /**
      * Returns the result premultiplying this by <code>m</code>.
      * @param m    matrix to premultiply by
@@ -326,7 +465,7 @@
     public BigMatrix preMultiply(BigMatrix m) throws IllegalArgumentException {
         return m.multiply(this);
     }
-    
+
     /**
      * Returns matrix entries as a two-dimensional array.
      * <p>
@@ -347,11 +486,11 @@
      * @return    2-dimensional array of entries
      */
     public double[][] getDataAsDoubleArray() {
-        int nRows = getRowDimension();
-        int nCols = getColumnDimension();
-        double d[][] = new double[nRows][nCols];
+        final int nRows = getRowDimension();
+        final int nCols = getColumnDimension();
+        final double d[][] = new double[nRows][nCols];
         for (int i = 0; i < nRows; i++) {
-            for (int j=0; j<nCols;j++) {
+            for (int j = 0; j < nCols; j++) {
                 d[i][j] = data[i][j].doubleValue();
             }
         }
@@ -437,23 +576,23 @@
      *         specified rows and columns
      * @exception MatrixIndexException if row or column selections are not valid
      */
-    public BigMatrix getSubMatrix(int startRow, int endRow, int startColumn,
-            int endColumn) throws MatrixIndexException {
+    public BigMatrix getSubMatrix(int startRow, int endRow,
+                                  int startColumn, int endColumn)
+        throws MatrixIndexException {
         if (startRow < 0 || startRow > endRow || endRow > data.length ||
                 startColumn < 0 || startColumn > endColumn ||
                 endColumn > data[0].length ) {
             throw new MatrixIndexException(
             "invalid row or column index selection");
         }
-        BigMatrixImpl subMatrix = new BigMatrixImpl(endRow - startRow+1,
-                endColumn - startColumn+1);
-        BigDecimal[][] subMatrixData = subMatrix.getDataRef();
+        final BigDecimal[][] subMatrixData =
+            new BigDecimal[endRow - startRow + 1][endColumn - startColumn + 1];
         for (int i = startRow; i <= endRow; i++) {
-            for (int j = startColumn; j <= endColumn; j++) {
-                subMatrixData[i - startRow][j - startColumn] = data[i][j];
-            }
+            System.arraycopy(data[i], startColumn,
+                    subMatrixData[i - startRow], 0,
+                    endColumn - startColumn + 1);
         }
-        return subMatrix;
+        return new BigMatrixImpl(subMatrixData, false);
     }
     
     /**
@@ -468,25 +607,26 @@
      *     are not valid
      */
     public BigMatrix getSubMatrix(int[] selectedRows, int[] selectedColumns)
-    throws MatrixIndexException {
+        throws MatrixIndexException {
         if (selectedRows.length * selectedColumns.length == 0) {
             throw new MatrixIndexException(
             "selected row and column index arrays must be non-empty");
         }
-        BigMatrixImpl subMatrix = new BigMatrixImpl(selectedRows.length,
-                selectedColumns.length);
-        BigDecimal[][] subMatrixData = subMatrix.getDataRef();
+        final BigDecimal[][] subMatrixData =
+            new BigDecimal[selectedRows.length][selectedColumns.length];
         try  {
             for (int i = 0; i < selectedRows.length; i++) {
+                final BigDecimal[] subI = subMatrixData[i];
+                final BigDecimal[] dataSelectedI = data[selectedRows[i]];
                 for (int j = 0; j < selectedColumns.length; j++) {
-                    subMatrixData[i][j] = data[selectedRows[i]][selectedColumns[j]];
+                    subI[j] = dataSelectedI[selectedColumns[j]];
                 }
             }
         }
         catch (ArrayIndexOutOfBoundsException e) {
             throw new MatrixIndexException("matrix dimension mismatch");
         }
-        return subMatrix;
+        return new BigMatrixImpl(subMatrixData, false);
     } 
     
     /**
@@ -522,12 +662,12 @@
             throw new MatrixIndexException
             ("invalid row or column index selection");          
         }
-        int nRows = subMatrix.length;
+        final int nRows = subMatrix.length;
         if (nRows == 0) {
             throw new IllegalArgumentException(
             "Matrix must have at least one row."); 
         }
-        int nCols = subMatrix[0].length;
+        final int nCols = subMatrix[0].length;
         if (nCols == 0) {
             throw new IllegalArgumentException(
             "Matrix must have at least one column."); 
@@ -566,10 +706,10 @@
         if ( !isValidCoordinate( row, 0)) {
             throw new MatrixIndexException("illegal row argument");
         }
-        int ncols = this.getColumnDimension();
-        BigDecimal[][] out = new BigDecimal[1][ncols]; 
+        final int ncols = this.getColumnDimension();
+        final BigDecimal[][] out = new BigDecimal[1][ncols]; 
         System.arraycopy(data[row], 0, out[0], 0, ncols);
-        return new BigMatrixImpl(out);
+        return new BigMatrixImpl(out, false);
     } 
     
     /**
@@ -584,12 +724,12 @@
         if ( !isValidCoordinate( 0, column)) {
             throw new MatrixIndexException("illegal column argument");
         }
-        int nRows = this.getRowDimension();
-        BigDecimal[][] out = new BigDecimal[nRows][1]; 
+        final int nRows = this.getRowDimension();
+        final BigDecimal[][] out = new BigDecimal[nRows][1]; 
         for (int row = 0; row < nRows; row++) {
             out[row][0] = data[row][column];
         }
-        return new BigMatrixImpl(out);
+        return new BigMatrixImpl(out, false);
     }
     
     /**
@@ -606,8 +746,8 @@
         if ( !isValidCoordinate( row, 0 ) ) {
             throw new MatrixIndexException("illegal row argument");
         }
-        int ncols = this.getColumnDimension();
-        BigDecimal[] out = new BigDecimal[ncols];
+        final int ncols = this.getColumnDimension();
+        final BigDecimal[] out = new BigDecimal[ncols];
         System.arraycopy(data[row], 0, out, 0, ncols);
         return out;
     }
@@ -627,8 +767,8 @@
         if ( !isValidCoordinate( row, 0 ) ) {
             throw new MatrixIndexException("illegal row argument");
         }
-        int ncols = this.getColumnDimension();
-        double[] out = new double[ncols];
+        final int ncols = this.getColumnDimension();
+        final double[] out = new double[ncols];
         for (int i=0;i<ncols;i++) {
             out[i] = data[row][i].doubleValue();
         }
@@ -649,8 +789,8 @@
         if ( !isValidCoordinate(0, col) ) {
             throw new MatrixIndexException("illegal column argument");
         }
-        int nRows = this.getRowDimension();
-        BigDecimal[] out = new BigDecimal[nRows];
+        final int nRows = this.getRowDimension();
+        final BigDecimal[] out = new BigDecimal[nRows];
         for (int i = 0; i < nRows; i++) {
             out[i] = data[i][col];
         }
@@ -672,8 +812,8 @@
         if ( !isValidCoordinate( 0, col ) ) {
             throw new MatrixIndexException("illegal column argument");
         }
-        int nrows = this.getRowDimension();
-        double[] out = new double[nrows];
+        final int nrows = this.getRowDimension();
+        final double[] out = new double[nrows];
         for (int i=0;i<nrows;i++) {
             out[i] = data[i][col].doubleValue();
         }
@@ -697,10 +837,11 @@
      */
     public BigDecimal getEntry(int row, int column)
     throws MatrixIndexException {
-        if (!isValidCoordinate(row,column)) {
+        try {
+            return data[row][column];
+        } catch (ArrayIndexOutOfBoundsException e) {
             throw new MatrixIndexException("matrix entry does not exist");
         }
-        return data[row][column];
     }
     
     /**
@@ -729,16 +870,16 @@
      * @return transpose matrix
      */
     public BigMatrix transpose() {
-        int nRows = this.getRowDimension();
-        int nCols = this.getColumnDimension();
-        BigMatrixImpl out = new BigMatrixImpl(nCols, nRows);
-        BigDecimal[][] outData = out.getDataRef();
+        final int nRows = this.getRowDimension();
+        final int nCols = this.getColumnDimension();
+        final BigDecimal[][] outData = new BigDecimal[nCols][nRows];
         for (int row = 0; row < nRows; row++) {
+            final BigDecimal[] dataRow = data[row];
             for (int col = 0; col < nCols; col++) {
-                outData[col][row] = data[row][col];
+                outData[col][row] = dataRow[col];
             }
         }
-        return out;
+        return new BigMatrixImpl(outData, false);
     }
     
     /**
@@ -748,8 +889,7 @@
      * @throws InvalidMatrixException if this is not invertible
      */
     public BigMatrix inverse() throws InvalidMatrixException {
-        return solve(MatrixUtils.createBigIdentityMatrix
-                (this.getRowDimension()));
+        return solve(MatrixUtils.createBigIdentityMatrix(getRowDimension()));
     }
     
     /**
@@ -846,9 +986,9 @@
         if (v.length != this.getColumnDimension()) {
             throw new IllegalArgumentException("vector has wrong length");
         }
-        int nRows = this.getRowDimension();
-        int nCols = this.getColumnDimension();
-        BigDecimal[] out = new BigDecimal[v.length];
+        final int nRows = this.getRowDimension();
+        final int nCols = this.getColumnDimension();
+        final BigDecimal[] out = new BigDecimal[v.length];
         for (int row = 0; row < nRows; row++) {
             BigDecimal sum = ZERO;
             for (int i = 0; i < nCols; i++) {
@@ -867,8 +1007,8 @@
      * @throws IllegalArgumentException if columnDimension != v.size()
      */
     public BigDecimal[] operate(double[] v) throws IllegalArgumentException {
-        BigDecimal bd[] = new BigDecimal[v.length];
-        for (int i=0;i<bd.length;i++) {
+        final BigDecimal bd[] = new BigDecimal[v.length];
+        for (int i = 0; i < bd.length; i++) {
             bd[i] = new BigDecimal(v[i]);
         }
         return operate(bd);
@@ -882,12 +1022,12 @@
      * @throws IllegalArgumentException if rowDimension != v.size()
      */
     public BigDecimal[] preMultiply(BigDecimal[] v) throws IllegalArgumentException {
-        int nRows = this.getRowDimension();
+        final int nRows = this.getRowDimension();
         if (v.length != nRows) {
             throw new IllegalArgumentException("vector has wrong length");
         }
-        int nCols = this.getColumnDimension();
-        BigDecimal[] out = new BigDecimal[nCols];
+        final int nCols = this.getColumnDimension();
+        final BigDecimal[] out = new BigDecimal[nCols];
         for (int col = 0; col < nCols; col++) {
             BigDecimal sum = ZERO;
             for (int i = 0; i < nRows; i++) {
@@ -910,13 +1050,13 @@
      * @throws InvalidMatrixException if this matrix is not square or is singular
      */
     public BigDecimal[] solve(BigDecimal[] b) throws IllegalArgumentException, InvalidMatrixException {
-        int nRows = this.getRowDimension();
+        final int nRows = this.getRowDimension();
         if (b.length != nRows) {
             throw new IllegalArgumentException("constant vector has wrong length");
         }
-        BigMatrix bMatrix = new BigMatrixImpl(b);
-        BigDecimal[][] solution = ((BigMatrixImpl) (solve(bMatrix))).getDataRef();
-        BigDecimal[] out = new BigDecimal[nRows];
+        final BigMatrix bMatrix = new BigMatrixImpl(b);
+        final BigDecimal[][] solution = ((BigMatrixImpl) (solve(bMatrix))).getDataRef();
+        final BigDecimal[] out = new BigDecimal[nRows];
         for (int row = 0; row < nRows; row++) {
             out[row] = solution[row][0];
         }
@@ -935,8 +1075,8 @@
      * @throws InvalidMatrixException if this matrix is not square or is singular
      */
     public BigDecimal[] solve(double[] b) throws IllegalArgumentException, InvalidMatrixException {
-        BigDecimal bd[] = new BigDecimal[b.length];
-        for (int i=0;i<bd.length;i++) {
+        final BigDecimal bd[] = new BigDecimal[b.length];
+        for (int i = 0; i < bd.length; i++) {
             bd[i] = new BigDecimal(b[i]);
         }
         return solve(bd);
@@ -964,41 +1104,48 @@
             throw new InvalidMatrixException("Matrix is singular.");
         }
         
-        int nCol = this.getColumnDimension();
-        int nColB = b.getColumnDimension();
-        int nRowB = b.getRowDimension();
+        final int nCol = this.getColumnDimension();
+        final int nColB = b.getColumnDimension();
+        final int nRowB = b.getRowDimension();
         
         // Apply permutations to b
-        BigDecimal[][] bp = new BigDecimal[nRowB][nColB];
+        final BigDecimal[][] bp = new BigDecimal[nRowB][nColB];
         for (int row = 0; row < nRowB; row++) {
+            final BigDecimal[] bpRow = bp[row];
             for (int col = 0; col < nColB; col++) {
-                bp[row][col] = b.getEntry(permutation[row], col);
+                bpRow[col] = b.getEntry(permutation[row], col);
             }
         }
         
         // Solve LY = b
         for (int col = 0; col < nCol; col++) {
             for (int i = col + 1; i < nCol; i++) {
+                final BigDecimal[] bpI = bp[i];
+                final BigDecimal[] luI = lu[i];
                 for (int j = 0; j < nColB; j++) {
-                    bp[i][j] = bp[i][j].subtract(bp[col][j].multiply(lu[i][col]));
+                    bpI[j] = bpI[j].subtract(bp[col][j].multiply(luI[col]));
                 }
             }
         }
         
         // Solve UX = Y
         for (int col = nCol - 1; col >= 0; col--) {
+            final BigDecimal[] bpCol = bp[col];
+            final BigDecimal luDiag = lu[col][col];
             for (int j = 0; j < nColB; j++) {
-                bp[col][j] = bp[col][j].divide(lu[col][col], scale, roundingMode);
+                bpCol[j] = bpCol[j].divide(luDiag, scale, roundingMode);
             }
             for (int i = 0; i < col; i++) {
+                final BigDecimal[] bpI = bp[i];
+                final BigDecimal[] luI = lu[i];
                 for (int j = 0; j < nColB; j++) {
-                    bp[i][j] = bp[i][j].subtract(bp[col][j].multiply(lu[i][col]));
+                    bpI[j] = bpI[j].subtract(bp[col][j].multiply(luI[col]));
                 }
             }
         }
-        
-        BigMatrixImpl outMat = new BigMatrixImpl(bp);
-        return outMat;
+
+        return new BigMatrixImpl(bp, false);
+
     }
     
     /**
@@ -1021,8 +1168,8 @@
      */
     public void luDecompose() throws InvalidMatrixException {
         
-        int nRows = this.getRowDimension();
-        int nCols = this.getColumnDimension();
+        final int nRows = this.getRowDimension();
+        final int nCols = this.getColumnDimension();
         if (nRows != nCols) {
             throw new InvalidMatrixException("LU decomposition requires that the matrix be square.");
         }
@@ -1042,22 +1189,24 @@
             
             // upper
             for (int row = 0; row < col; row++) {
-                sum = lu[row][col];
+                final BigDecimal[] luRow = lu[row];
+                sum = luRow[col];
                 for (int i = 0; i < row; i++) {
-                    sum = sum.subtract(lu[row][i].multiply(lu[i][col]));
+                    sum = sum.subtract(luRow[i].multiply(lu[i][col]));
                 }
-                lu[row][col] = sum;
+                luRow[col] = sum;
             }
             
             // lower
             int max = col; // permutation row
             BigDecimal largest = ZERO;
             for (int row = col; row < nRows; row++) {
-                sum = lu[row][col];
+                final BigDecimal[] luRow = lu[row];
+                sum = luRow[col];
                 for (int i = 0; i < col; i++) {
-                    sum = sum.subtract(lu[row][i].multiply(lu[i][col]));
+                    sum = sum.subtract(luRow[i].multiply(lu[i][col]));
                 }
-                lu[row][col] = sum;
+                luRow[col] = sum;
                 
                 // maintain best permutation choice
                 if (sum.abs().compareTo(largest) == 1) {
@@ -1086,9 +1235,11 @@
                 parity = -parity;
             }
             
-            //Divide the lower elements by the "winning" diagonal elt.
+            // Divide the lower elements by the "winning" diagonal elt.
+            final BigDecimal luDiag = lu[col][col];
             for (int row = col + 1; row < nRows; row++) {
-                lu[row][col] = lu[row][col].divide(lu[col][col], scale, roundingMode);
+                final BigDecimal[] luRow = lu[row];
+                luRow[col] = luRow[col].divide(luDiag, scale, roundingMode);
             }
             
         }
@@ -1104,12 +1255,14 @@
         res.append("BigMatrixImpl{");
         if (data != null) {
             for (int i = 0; i < data.length; i++) {
-                if (i > 0)
+                if (i > 0) {
                     res.append(",");
+                }
                 res.append("{");
                 for (int j = 0; j < data[0].length; j++) {
-                    if (j > 0)
+                    if (j > 0) {
                         res.append(",");
+                    }
                     res.append(data[i][j]);
                 } 
                 res.append("}");
@@ -1135,15 +1288,16 @@
         if (object instanceof BigMatrixImpl == false) {
             return false;
         }
-        BigMatrix m = (BigMatrix) object;
-        int nRows = getRowDimension();
-        int nCols = getColumnDimension();
+        final BigMatrix m = (BigMatrix) object;
+        final int nRows = getRowDimension();
+        final int nCols = getColumnDimension();
         if (m.getColumnDimension() != nCols || m.getRowDimension() != nRows) {
             return false;
         }
         for (int row = 0; row < nRows; row++) {
+            final BigDecimal[] dataRow = data[row];
             for (int col = 0; col < nCols; col++) {
-                if (!data[row][col].equals(m.getEntry(row, col))) {
+                if (!dataRow[col].equals(m.getEntry(row, col))) {
                     return false;
                 }
             }
@@ -1158,14 +1312,15 @@
      */
     public int hashCode() {
         int ret = 7;
-        int nRows = getRowDimension();
-        int nCols = getColumnDimension();
+        final int nRows = getRowDimension();
+        final int nCols = getColumnDimension();
         ret = ret * 31 + nRows;
         ret = ret * 31 + nCols;
         for (int row = 0; row < nRows; row++) {
+            final BigDecimal[] dataRow = data[row];
             for (int col = 0; col < nCols; col++) {
                 ret = ret * 31 + (11 * (row+1) + 17 * (col+1)) * 
-                data[row][col].hashCode();
+                dataRow[col].hashCode();
             }
         }   
         return ret;
@@ -1220,7 +1375,7 @@
      * @return the permutation
      */
     protected int[] getPermutation() {
-        int[] out = new int[permutation.length];
+        final int[] out = new int[permutation.length];
         System.arraycopy(permutation, 0, out, 0, permutation.length);
         return out;
     }
@@ -1233,8 +1388,8 @@
      * @return a copy of the underlying data array.
      */
     private BigDecimal[][] copyOut() {
-        int nRows = this.getRowDimension();
-        BigDecimal[][] out = new BigDecimal[nRows][this.getColumnDimension()];
+        final int nRows = this.getRowDimension();
+        final BigDecimal[][] out = new BigDecimal[nRows][this.getColumnDimension()];
         // can't copy 2-d array in one shot, otherwise get row references
         for (int i = 0; i < nRows; i++) {
             System.arraycopy(data[i], 0, out[i], 0, data[i].length);
@@ -1262,12 +1417,14 @@
      * @param in data to copy in
      */
     private void copyIn(double[][] in) {
-        int nRows = in.length;
-        int nCols = in[0].length;
+        final int nRows = in.length;
+        final int nCols = in[0].length;
         data = new BigDecimal[nRows][nCols];
         for (int i = 0; i < nRows; i++) {
-            for (int j=0; j < nCols; j++) {
-                data[i][j] = new BigDecimal(in[i][j]);
+            final BigDecimal[] dataI = data[i];
+            final double[] inI = in[i];
+            for (int j = 0; j < nCols; j++) {
+                dataI[j] = new BigDecimal(inI[j]);
             }
         }
         lu = null;
@@ -1280,12 +1437,14 @@
      * @param in data to copy in
      */
     private void copyIn(String[][] in) {
-        int nRows = in.length;
-        int nCols = in[0].length;
+        final int nRows = in.length;
+        final int nCols = in[0].length;
         data = new BigDecimal[nRows][nCols];
         for (int i = 0; i < nRows; i++) {
-            for (int j=0; j < nCols; j++) {
-                data[i][j] = new BigDecimal(in[i][j]);
+            final BigDecimal[] dataI = data[i];
+            final String[] inI = in[i];
+            for (int j = 0; j < nCols; j++) {
+                dataI[j] = new BigDecimal(inI[j]);
             }
         }
         lu = null;
@@ -1299,9 +1458,8 @@
      * @return true if the coordinate is with the current dimensions
      */
     private boolean isValidCoordinate(int row, int col) {
-        int nRows = this.getRowDimension();
-        int nCols = this.getColumnDimension();
-        
+        final int nRows = this.getRowDimension();
+        final int nCols = this.getColumnDimension();
         return !(row < 0 || row >= nRows || col < 0 || col >= nCols);
     }
     

Modified: commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/MatrixUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/MatrixUtils.java?rev=662241&r1=662240&r2=662241&view=diff
==============================================================================
--- commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/MatrixUtils.java (original)
+++ commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/MatrixUtils.java Sun Jun  1 09:22:19 2008
@@ -18,6 +18,7 @@
 package org.apache.commons.math.linear;
 
 import java.math.BigDecimal;
+import java.util.Arrays;
 
 /**
  * A collection of static methods that operate on or return matrices.
@@ -41,12 +42,33 @@
      * @return  RealMatrix containing the values of the array
      * @throws IllegalArgumentException if <code>data</code> is not rectangular
      *  (not all rows have the same length) or empty
-     * @throws NullPointerException if data is null
+     * @throws NullPointerException if <code>data</code> is null
+     * @see #createRealMatrix(double[][], boolean)
      */
     public static RealMatrix createRealMatrix(double[][] data) {
         return new RealMatrixImpl(data);
     }
-    
+
+    /**
+     * Returns a {@link RealMatrix} whose entries are the the values in the
+     * the input array.
+     * <p>If an array is built specially in order to be embedded in a
+     * RealMatrix and not used directly, the <code>copyArray</code> may be
+     * set to <code>false</code. This will prevent the copying and improve
+     * performance as no new array will be built and no data will be copied.</p>
+     * @param data data for new matrix
+     * @param copyArray if true, the input array will be copied, otherwise
+     * it will be referenced
+     * @return  RealMatrix containing the values of the array
+     * @throws IllegalArgumentException if <code>data</code> is not rectangular
+     *  (not all rows have the same length) or empty
+     * @throws NullPointerException if <code>data</code> is null
+     * @see #createRealMatrix(double[][])
+     */
+    public static RealMatrix createRealMatrix(double[][] data, boolean copyArray) {
+        return new RealMatrixImpl(data, copyArray);
+    }
+
     /**
      * Returns <code>dimension x dimension</code> identity matrix.
      *
@@ -56,14 +78,11 @@
      * @since 1.1
      */
     public static RealMatrix createRealIdentityMatrix(int dimension) {
-        RealMatrixImpl out = new RealMatrixImpl(dimension, dimension);
-        double[][] d = out.getDataRef();
+        double[][] d = new double[dimension][dimension];
         for (int row = 0; row < dimension; row++) {
-            for (int col = 0; col < dimension; col++) {
-                d[row][col] = row == col ? 1d : 0d;
-            }
+            d[row][row] = 1d;
         }
-        return out;
+        return new RealMatrixImpl(d, false);
     }
     
     /**
@@ -93,7 +112,27 @@
     public static BigMatrix createBigMatrix(BigDecimal[][] data) {
         return new BigMatrixImpl(data);
     }
-    
+
+    /**
+     * Returns a {@link BigMatrix} whose entries are the the values in the
+     * the input array.
+     * <p>If an array is built specially in order to be embedded in a
+     * BigMatrix and not used directly, the <code>copyArray</code> may be
+     * set to <code>false</code. This will prevent the copying and improve
+     * performance as no new array will be built and no data will be copied.</p>
+     * @param data data for new matrix
+     * @param copyArray if true, the input array will be copied, otherwise
+     * it will be referenced
+     * @return  BigMatrix containing the values of the array
+     * @throws IllegalArgumentException if <code>data</code> is not rectangular
+     *  (not all rows have the same length) or empty
+     * @throws NullPointerException if <code>data</code> is null
+     * @see #createRealMatrix(double[][])
+     */
+    public static BigMatrix createBigMatrix(BigDecimal[][] data, boolean copyArray) {
+        return new BigMatrixImpl(data, copyArray);
+    }
+
     /**
      * Returns a {@link BigMatrix} whose entries are the the values in the
      * the input array.  The input array is copied, not referenced.
@@ -118,10 +157,10 @@
      * @throws NullPointerException if <code>rowData</code>is null
      */
     public static RealMatrix createRowRealMatrix(double[] rowData) {
-        int nCols = rowData.length;
-        double[][] data = new double[1][nCols];
+        final int nCols = rowData.length;
+        final double[][] data = new double[1][nCols];
         System.arraycopy(rowData, 0, data[0], 0, nCols);
-        return new RealMatrixImpl(data);
+        return new RealMatrixImpl(data, false);
     }
     
     /**
@@ -134,10 +173,12 @@
      * @throws NullPointerException if <code>rowData</code>is null
      */
     public static BigMatrix createRowBigMatrix(double[] rowData) {
-        int nCols = rowData.length;
-        double[][] data = new double[1][nCols];
-        System.arraycopy(rowData, 0, data[0], 0, nCols);
-        return new BigMatrixImpl(data);
+        final int nCols = rowData.length;
+        final BigDecimal[][] data = new BigDecimal[1][nCols];
+        for (int i = 0; i < nCols; ++i) {
+            data[0][i] = new BigDecimal(rowData[i]);
+        }
+        return new BigMatrixImpl(data, false);
     }
     
     /**
@@ -150,10 +191,10 @@
      * @throws NullPointerException if <code>rowData</code>is null
      */
     public static BigMatrix createRowBigMatrix(BigDecimal[] rowData) {
-        int nCols = rowData.length;
-        BigDecimal[][] data = new BigDecimal[1][nCols];
+        final int nCols = rowData.length;
+        final BigDecimal[][] data = new BigDecimal[1][nCols];
         System.arraycopy(rowData, 0, data[0], 0, nCols);
-        return new BigMatrixImpl(data);
+        return new BigMatrixImpl(data, false);
     }
     
     /**
@@ -166,10 +207,12 @@
      * @throws NullPointerException if <code>rowData</code>is null
      */
     public static BigMatrix createRowBigMatrix(String[] rowData) {
-        int nCols = rowData.length;
-        String[][] data = new String[1][nCols];
-        System.arraycopy(rowData, 0, data[0], 0, nCols);
-        return new BigMatrixImpl(data);
+        final int nCols = rowData.length;
+        final BigDecimal[][] data = new BigDecimal[1][nCols];
+        for (int i = 0; i < nCols; ++i) {
+            data[0][i] = new BigDecimal(rowData[i]);
+        }
+        return new BigMatrixImpl(data, false);
     }
     
     /**
@@ -182,12 +225,12 @@
      * @throws NullPointerException if <code>columnData</code>is null
      */
     public static RealMatrix createColumnRealMatrix(double[] columnData) {
-        int nRows = columnData.length;
-        double[][] data = new double[nRows][1];
+        final int nRows = columnData.length;
+        final double[][] data = new double[nRows][1];
         for (int row = 0; row < nRows; row++) {
             data[row][0] = columnData[row];
         }
-        return new RealMatrixImpl(data);
+        return new RealMatrixImpl(data, false);
     }
     
     /**
@@ -200,12 +243,12 @@
      * @throws NullPointerException if <code>columnData</code>is null
      */
     public static BigMatrix createColumnBigMatrix(double[] columnData) {
-        int nRows = columnData.length;
-        double[][] data = new double[nRows][1];
+        final int nRows = columnData.length;
+        final BigDecimal[][] data = new BigDecimal[nRows][1];
         for (int row = 0; row < nRows; row++) {
-            data[row][0] = columnData[row];
+            data[row][0] = new BigDecimal(columnData[row]);
         }
-        return new BigMatrixImpl(data);
+        return new BigMatrixImpl(data, false);
     }
     
     /**
@@ -218,12 +261,12 @@
      * @throws NullPointerException if <code>columnData</code>is null
      */
     public static BigMatrix createColumnBigMatrix(BigDecimal[] columnData) {
-        int nRows = columnData.length;
-        BigDecimal[][] data = new BigDecimal[nRows][1];
+        final int nRows = columnData.length;
+        final BigDecimal[][] data = new BigDecimal[nRows][1];
         for (int row = 0; row < nRows; row++) {
             data[row][0] = columnData[row];
         }
-        return new BigMatrixImpl(data);
+        return new BigMatrixImpl(data, false);
     }
     
     /**
@@ -237,11 +280,11 @@
      */
     public static BigMatrix createColumnBigMatrix(String[] columnData) {
         int nRows = columnData.length;
-        String[][] data = new String[nRows][1];
+        final BigDecimal[][] data = new BigDecimal[nRows][1];
         for (int row = 0; row < nRows; row++) {
-            data[row][0] = columnData[row];
+            data[row][0] = new BigDecimal(columnData[row]);
         }
-        return new BigMatrixImpl(data);
+        return new BigMatrixImpl(data, false);
     }
     
     /**
@@ -253,14 +296,13 @@
      * @since 1.1
      */
     public static BigMatrix createBigIdentityMatrix(int dimension) {
-        BigMatrixImpl out = new BigMatrixImpl(dimension, dimension);
-        BigDecimal[][] d = out.getDataRef();
+        final BigDecimal[][] d = new BigDecimal[dimension][dimension];
         for (int row = 0; row < dimension; row++) {
-            for (int col = 0; col < dimension; col++) {
-                d[row][col] = row == col ? BigMatrixImpl.ONE : BigMatrixImpl.ZERO;
-            }
+            final BigDecimal[] dRow = d[row];
+            Arrays.fill(dRow, BigMatrixImpl.ZERO);
+            dRow[row] = BigMatrixImpl.ONE;
         }
-        return out;
+        return new BigMatrixImpl(d, false);
     }
     
 }

Modified: commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealMatrixImpl.java
URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealMatrixImpl.java?rev=662241&r1=662240&r2=662241&view=diff
==============================================================================
--- commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealMatrixImpl.java (original)
+++ commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/linear/RealMatrixImpl.java Sun Jun  1 09:22:19 2008
@@ -52,7 +52,7 @@
 public class RealMatrixImpl implements RealMatrix, Serializable {
     
     /** Serializable version identifier */
-    private static final long serialVersionUID = 4237564493130426188L;
+    private static final long serialVersionUID = -4828886979278117018L;
 
     /** Entries of the matrix */
     private double data[][] = null;
@@ -97,16 +97,58 @@
     /**
      * Create a new RealMatrix using the input array as the underlying
      * data array.
-     * <p>
-     * The input array is copied, not referenced.</p>
+     * <p>The input array is copied, not referenced. This constructor has
+     * the same effect as calling {@link #RealMatrixImpl(double[][], boolean)}
+     * with the second argument set to <code>true</code>.</p>
      *
      * @param d data for new matrix
      * @throws IllegalArgumentException if <code>d</code> is not rectangular
      *  (not all rows have the same length) or empty
      * @throws NullPointerException if <code>d</code> is null
+     * @see #RealMatrixImpl(double[][], boolean)
      */
     public RealMatrixImpl(double[][] d) {
-        this.copyIn(d);
+        copyIn(d);
+        lu = null;
+    }
+
+    /**
+     * Create a new RealMatrix using the input array as the underlying
+     * data array.
+     * <p>If an array is built specially in order to be embedded in a
+     * RealMatrix and not used directly, the <code>copyArray</code> may be
+     * set to <code>false</code. This will prevent the copying and improve
+     * performance as no new array will be built and no data will be copied.</p>
+     * @param d data for new matrix
+     * @param copyArray if true, the input array will be copied, otherwise
+     * it will be referenced
+     * @throws IllegalArgumentException if <code>d</code> is not rectangular
+     *  (not all rows have the same length) or empty
+     * @throws NullPointerException if <code>d</code> is null
+     * @see #RealMatrixImpl(double[][])
+     */
+    public RealMatrixImpl(double[][] d, boolean copyArray) {
+        if (copyArray) {
+            copyIn(d);
+        } else {
+            if (d == null) {
+                throw new NullPointerException();
+            }   
+            final int nRows = d.length;
+            if (nRows == 0) {
+                throw new IllegalArgumentException("Matrix must have at least one row."); 
+            }
+            final int nCols = d[0].length;
+            if (nCols == 0) {
+                throw new IllegalArgumentException("Matrix must have at least one column."); 
+            }
+            for (int r = 1; r < nRows; r++) {
+                if (d[r].length != nCols) {
+                    throw new IllegalArgumentException("All input rows must have the same length.");
+                }
+            }       
+            data = d;
+        }
         lu = null;
     }
 
@@ -114,13 +156,12 @@
      * Create a new (column) RealMatrix using <code>v</code> as the
      * data for the unique column of the <code>v.length x 1</code> matrix
      * created.
-     * <p>
-     * The input array is copied, not referenced.</p>
+     * <p>The input array is copied, not referenced.</p>
      *
      * @param v column vector holding data for new matrix
      */
     public RealMatrixImpl(double[] v) {
-        int nRows = v.length;
+        final int nRows = v.length;
         data = new double[nRows][1];
         for (int row = 0; row < nRows; row++) {
             data[row][0] = v[row];
@@ -133,7 +174,7 @@
      * @return  the cloned matrix
      */
     public RealMatrix copy() {
-        return new RealMatrixImpl(this.copyOut());
+        return new RealMatrixImpl(copyOut(), false);
     }
 
     /**
@@ -144,19 +185,49 @@
      * @throws  IllegalArgumentException if m is not the same size as this
      */
     public RealMatrix add(RealMatrix m) throws IllegalArgumentException {
-        if (this.getColumnDimension() != m.getColumnDimension() ||
-                this.getRowDimension() != m.getRowDimension()) {
+        try {
+            return add((RealMatrixImpl) m);
+        } catch (ClassCastException cce) {
+            final int rowCount    = getRowDimension();
+            final int columnCount = getColumnDimension();
+            if (columnCount != m.getColumnDimension() || rowCount != m.getRowDimension()) {
+                throw new IllegalArgumentException("matrix dimension mismatch");
+            }
+            final double[][] outData = new double[rowCount][columnCount];
+            for (int row = 0; row < rowCount; row++) {
+                final double[] dataRow    = data[row];
+                final double[] outDataRow = outData[row];
+                for (int col = 0; col < columnCount; col++) {
+                    outDataRow[col] = dataRow[col] + m.getEntry(row, col);
+                }  
+            }
+            return new RealMatrixImpl(outData, false);
+        }
+    }
+
+    /**
+     * Compute the sum of this and <code>m</code>.
+     *
+     * @param m    matrix to be added
+     * @return     this + m
+     * @throws  IllegalArgumentException if m is not the same size as this
+     */
+    public RealMatrixImpl add(RealMatrixImpl m) throws IllegalArgumentException {
+        final int rowCount    = getRowDimension();
+        final int columnCount = getColumnDimension();
+        if (columnCount != m.getColumnDimension() || rowCount != m.getRowDimension()) {
             throw new IllegalArgumentException("matrix dimension mismatch");
         }
-        int rowCount = this.getRowDimension();
-        int columnCount = this.getColumnDimension();
-        double[][] outData = new double[rowCount][columnCount];
+        final double[][] outData = new double[rowCount][columnCount];
         for (int row = 0; row < rowCount; row++) {
+            final double[] dataRow    = data[row];
+            final double[] mRow       = m.data[row];
+            final double[] outDataRow = outData[row];
             for (int col = 0; col < columnCount; col++) {
-                outData[row][col] = data[row][col] + m.getEntry(row, col);
+                outDataRow[col] = dataRow[col] + mRow[col];
             }  
         }
-        return new RealMatrixImpl(outData);
+        return new RealMatrixImpl(outData, false);
     }
 
     /**
@@ -167,19 +238,49 @@
      * @throws  IllegalArgumentException if m is not the same size as this
      */
     public RealMatrix subtract(RealMatrix m) throws IllegalArgumentException {
-        if (this.getColumnDimension() != m.getColumnDimension() ||
-                this.getRowDimension() != m.getRowDimension()) {
+        try {
+            return subtract((RealMatrixImpl) m);
+        } catch (ClassCastException cce) {
+            final int rowCount    = getRowDimension();
+            final int columnCount = getColumnDimension();
+            if (columnCount != m.getColumnDimension() || rowCount != m.getRowDimension()) {
+                throw new IllegalArgumentException("matrix dimension mismatch");
+            }
+            final double[][] outData = new double[rowCount][columnCount];
+            for (int row = 0; row < rowCount; row++) {
+                final double[] dataRow    = data[row];
+                final double[] outDataRow = outData[row];
+                for (int col = 0; col < columnCount; col++) {
+                    outDataRow[col] = dataRow[col] - m.getEntry(row, col);
+                }  
+            }
+            return new RealMatrixImpl(outData, false);
+        }
+    }
+
+    /**
+     * Compute  this minus <code>m</code>.
+     *
+     * @param m    matrix to be subtracted
+     * @return     this + m
+     * @throws  IllegalArgumentException if m is not the same size as this
+     */
+    public RealMatrixImpl subtract(RealMatrixImpl m) throws IllegalArgumentException {
+        final int rowCount    = getRowDimension();
+        final int columnCount = getColumnDimension();
+        if (columnCount != m.getColumnDimension() || rowCount != m.getRowDimension()) {
             throw new IllegalArgumentException("matrix dimension mismatch");
         }
-        int rowCount = this.getRowDimension();
-        int columnCount = this.getColumnDimension();
-        double[][] outData = new double[rowCount][columnCount];
+        final double[][] outData = new double[rowCount][columnCount];
         for (int row = 0; row < rowCount; row++) {
+            final double[] dataRow    = data[row];
+            final double[] mRow       = m.data[row];
+            final double[] outDataRow = outData[row];
             for (int col = 0; col < columnCount; col++) {
-                outData[row][col] = data[row][col] - m.getEntry(row, col);
-            }
+                outDataRow[col] = dataRow[col] - mRow[col];
+            }  
         }
-        return new RealMatrixImpl(outData);
+        return new RealMatrixImpl(outData, false);
     }
 
     /**
@@ -189,32 +290,36 @@
      * @return     d + this
      */
     public RealMatrix scalarAdd(double d) {
-        int rowCount = this.getRowDimension();
-        int columnCount = this.getColumnDimension();
-        double[][] outData = new double[rowCount][columnCount];
+        final int rowCount    = getRowDimension();
+        final int columnCount = getColumnDimension();
+        final double[][] outData = new double[rowCount][columnCount];
         for (int row = 0; row < rowCount; row++) {
+            final double[] dataRow    = data[row];
+            final double[] outDataRow = outData[row];
             for (int col = 0; col < columnCount; col++) {
-                outData[row][col] = data[row][col] + d;
+                outDataRow[col] = dataRow[col] + d;
             }
         }
-        return new RealMatrixImpl(outData);
+        return new RealMatrixImpl(outData, false);
     }
 
     /**
-     * Returns the result multiplying each entry of this by <code>d</code>
+     * Returns the result of multiplying each entry of this by <code>d</code>
      * @param d  value to multiply all entries by
      * @return d * this
      */
     public RealMatrix scalarMultiply(double d) {
-        int rowCount = this.getRowDimension();
-        int columnCount = this.getColumnDimension();
-        double[][] outData = new double[rowCount][columnCount];
+        final int rowCount    = getRowDimension();
+        final int columnCount = getColumnDimension();
+        final double[][] outData = new double[rowCount][columnCount];
         for (int row = 0; row < rowCount; row++) {
+            final double[] dataRow    = data[row];
+            final double[] outDataRow = outData[row];
             for (int col = 0; col < columnCount; col++) {
-                outData[row][col] = data[row][col] * d;
+                outDataRow[col] = dataRow[col] * d;
             }
         }
-        return new RealMatrixImpl(outData);
+        return new RealMatrixImpl(outData, false);
     }
 
     /**
@@ -225,28 +330,62 @@
      *             if columnDimension(this) != rowDimension(m)
      */
     public RealMatrix multiply(RealMatrix m) throws IllegalArgumentException {
+        try {
+            return multiply((RealMatrixImpl) m);
+        } catch (ClassCastException cce) {
+            if (this.getColumnDimension() != m.getRowDimension()) {
+                throw new IllegalArgumentException("Matrices are not multiplication compatible.");
+            }
+            final int nRows = this.getRowDimension();
+            final int nCols = m.getColumnDimension();
+            final int nSum = this.getColumnDimension();
+            final double[][] outData = new double[nRows][nCols];
+            for (int row = 0; row < nRows; row++) {
+                final double[] dataRow    = data[row];
+                final double[] outDataRow = outData[row];
+                for (int col = 0; col < nCols; col++) {
+                    double sum = 0;
+                    for (int i = 0; i < nSum; i++) {
+                        sum += dataRow[i] * m.getEntry(i, col);
+                    }
+                    outDataRow[col] = sum;
+                }
+            }
+            return new RealMatrixImpl(outData, false);
+        }
+    }
+
+    /**
+     * Returns the result of postmultiplying this by <code>m</code>.
+     * @param m    matrix to postmultiply by
+     * @return     this*m
+     * @throws     IllegalArgumentException
+     *             if columnDimension(this) != rowDimension(m)
+     */
+    public RealMatrixImpl multiply(RealMatrixImpl m) throws IllegalArgumentException {
         if (this.getColumnDimension() != m.getRowDimension()) {
             throw new IllegalArgumentException("Matrices are not multiplication compatible.");
         }
-        int nRows = this.getRowDimension();
-        int nCols = m.getColumnDimension();
-        int nSum = this.getColumnDimension();
-        double[][] outData = new double[nRows][nCols];
-        double sum = 0;
+        final int nRows = this.getRowDimension();
+        final int nCols = m.getColumnDimension();
+        final int nSum = this.getColumnDimension();
+        final double[][] outData = new double[nRows][nCols];
         for (int row = 0; row < nRows; row++) {
+            final double[] dataRow    = data[row];
+            final double[] outDataRow = outData[row];
             for (int col = 0; col < nCols; col++) {
-                sum = 0;
+                double sum = 0;
                 for (int i = 0; i < nSum; i++) {
-                    sum += data[row][i] * m.getEntry(i, col);
+                    sum += dataRow[i] * m.data[i][col];
                 }
-                outData[row][col] = sum;
+                outDataRow[col] = sum;
             }
-        }
-        return new RealMatrixImpl(outData);
+        }            
+        return new RealMatrixImpl(outData, false);
     }
 
     /**
-     * Returns the result premultiplying this by <code>m</code>.
+     * Returns the result of premultiplying this by <code>m</code>.
      * @param m    matrix to premultiply by
      * @return     m * this
      * @throws     IllegalArgumentException
@@ -306,23 +445,23 @@
      *         specified rows and columns
      * @exception MatrixIndexException if row or column selections are not valid
      */
-    public RealMatrix getSubMatrix(int startRow, int endRow, int startColumn,
-            int endColumn) throws MatrixIndexException {
+    public RealMatrix getSubMatrix(int startRow, int endRow,
+                                   int startColumn, int endColumn)
+        throws MatrixIndexException {
         if (startRow < 0 || startRow > endRow || endRow > data.length ||
              startColumn < 0 || startColumn > endColumn ||
-             endColumn > data[0].length ) {
+             endColumn > data[0].length) {
             throw new MatrixIndexException(
                     "invalid row or column index selection");
         }
-        RealMatrixImpl subMatrix = new RealMatrixImpl(endRow - startRow+1,
-                endColumn - startColumn+1);
-        double[][] subMatrixData = subMatrix.getDataRef();
+        final double[][] subMatrixData =
+            new double[endRow - startRow + 1][endColumn - startColumn + 1];
         for (int i = startRow; i <= endRow; i++) {
-            for (int j = startColumn; j <= endColumn; j++) {
-                    subMatrixData[i - startRow][j - startColumn] = data[i][j];
-                }
-            }
-        return subMatrix;
+            System.arraycopy(data[i], startColumn,
+                             subMatrixData[i - startRow], 0,
+                             endColumn - startColumn + 1);
+        }
+        return new RealMatrixImpl(subMatrixData, false);
     }
     
     /**
@@ -337,25 +476,25 @@
      *     are not valid
      */
     public RealMatrix getSubMatrix(int[] selectedRows, int[] selectedColumns)
-    throws MatrixIndexException {
+        throws MatrixIndexException {
         if (selectedRows.length * selectedColumns.length == 0) {
             throw new MatrixIndexException(
                     "selected row and column index arrays must be non-empty");
         }
-        RealMatrixImpl subMatrix = new RealMatrixImpl(selectedRows.length,
-                selectedColumns.length);
-        double[][] subMatrixData = subMatrix.getDataRef();
+        final double[][] subMatrixData =
+            new double[selectedRows.length][selectedColumns.length];
         try  {
             for (int i = 0; i < selectedRows.length; i++) {
+                final double[] subI = subMatrixData[i];
+                final double[] dataSelectedI = data[selectedRows[i]];
                 for (int j = 0; j < selectedColumns.length; j++) {
-                    subMatrixData[i][j] = data[selectedRows[i]][selectedColumns[j]];
+                    subI[j] = dataSelectedI[selectedColumns[j]];
                 }
             }
-        }
-        catch (ArrayIndexOutOfBoundsException e) {
+        } catch (ArrayIndexOutOfBoundsException e) {
             throw new MatrixIndexException("matrix dimension mismatch");
         }
-        return subMatrix;
+        return new RealMatrixImpl(subMatrixData, false);
     } 
 
     /**
@@ -391,12 +530,12 @@
             throw new MatrixIndexException
                 ("invalid row or column index selection");          
         }
-        int nRows = subMatrix.length;
+        final int nRows = subMatrix.length;
         if (nRows == 0) {
             throw new IllegalArgumentException(
             "Matrix must have at least one row."); 
         }
-        int nCols = subMatrix[0].length;
+        final int nCols = subMatrix[0].length;
         if (nCols == 0) {
             throw new IllegalArgumentException(
             "Matrix must have at least one column."); 
@@ -435,10 +574,10 @@
         if ( !isValidCoordinate( row, 0)) {
             throw new MatrixIndexException("illegal row argument");
         }
-        int ncols = this.getColumnDimension();
-        double[][] out = new double[1][ncols]; 
+        final int ncols = this.getColumnDimension();
+        final double[][] out = new double[1][ncols]; 
         System.arraycopy(data[row], 0, out[0], 0, ncols);
-        return new RealMatrixImpl(out);
+        return new RealMatrixImpl(out, false);
     }
     
     /**
@@ -453,12 +592,12 @@
         if ( !isValidCoordinate( 0, column)) {
             throw new MatrixIndexException("illegal column argument");
         }
-        int nRows = this.getRowDimension();
-        double[][] out = new double[nRows][1]; 
+        final int nRows = this.getRowDimension();
+        final double[][] out = new double[nRows][1]; 
         for (int row = 0; row < nRows; row++) {
             out[row][0] = data[row][column];
         }
-        return new RealMatrixImpl(out);
+        return new RealMatrixImpl(out, false);
     }
 
      /**
@@ -475,8 +614,8 @@
         if ( !isValidCoordinate( row, 0 ) ) {
             throw new MatrixIndexException("illegal row argument");
         }
-        int ncols = this.getColumnDimension();
-        double[] out = new double[ncols];
+        final int ncols = this.getColumnDimension();
+        final double[] out = new double[ncols];
         System.arraycopy(data[row], 0, out, 0, ncols);
         return out;
     }
@@ -495,8 +634,8 @@
         if ( !isValidCoordinate(0, col) ) {
             throw new MatrixIndexException("illegal column argument");
         }
-        int nRows = this.getRowDimension();
-        double[] out = new double[nRows];
+        final int nRows = this.getRowDimension();
+        final double[] out = new double[nRows];
         for (int row = 0; row < nRows; row++) {
             out[row] = data[row][col];
         }
@@ -520,10 +659,11 @@
      */
     public double getEntry(int row, int column)
         throws MatrixIndexException {
-        if (!isValidCoordinate(row,column)) {
+        try {
+            return data[row][column];
+        } catch (ArrayIndexOutOfBoundsException e) {
             throw new MatrixIndexException("matrix entry does not exist");
         }
-        return data[row][column];
     }
 
     /**
@@ -532,16 +672,16 @@
      * @return transpose matrix
      */
     public RealMatrix transpose() {
-        int nRows = this.getRowDimension();
-        int nCols = this.getColumnDimension();
-        RealMatrixImpl out = new RealMatrixImpl(nCols, nRows);
-        double[][] outData = out.getDataRef();
+        final int nRows = getRowDimension();
+        final int nCols = getColumnDimension();
+        final double[][] outData = new double[nCols][nRows];
         for (int row = 0; row < nRows; row++) {
+            final double[] dataRow = data[row];
             for (int col = 0; col < nCols; col++) {
-                outData[col][row] = data[row][col];
+                outData[col][row] = dataRow[col];
             }
         }
-        return out;
+        return new RealMatrixImpl(outData, false);
     }
 
     /**
@@ -551,8 +691,7 @@
      * @throws InvalidMatrixException if this is not invertible
      */
     public RealMatrix inverse() throws InvalidMatrixException {
-        return solve(MatrixUtils.createRealIdentityMatrix
-                (this.getRowDimension()));
+        return solve(MatrixUtils.createRealIdentityMatrix(getRowDimension()));
     }
 
     /**
@@ -632,16 +771,17 @@
      * @return resulting vector
      */
     public double[] operate(double[] v) throws IllegalArgumentException {
-        if (v.length != this.getColumnDimension()) {
+        final int nRows = this.getRowDimension();
+        final int nCols = this.getColumnDimension();
+        if (v.length != nCols) {
             throw new IllegalArgumentException("vector has wrong length");
         }
-        int nRows = this.getRowDimension();
-        int nCols = this.getColumnDimension();
-        double[] out = new double[v.length];
+        final double[] out = new double[v.length];
         for (int row = 0; row < nRows; row++) {
+            final double[] dataRow = data[row];
             double sum = 0;
             for (int i = 0; i < nCols; i++) {
-                sum += data[row][i] * v[i];
+                sum += dataRow[i] * v[i];
             }
             out[row] = sum;
         }
@@ -654,12 +794,12 @@
      * @return resulting matrix
      */
     public double[] preMultiply(double[] v) throws IllegalArgumentException {
-        int nRows = this.getRowDimension();
+        final int nRows = this.getRowDimension();
         if (v.length != nRows) {
             throw new IllegalArgumentException("vector has wrong length");
         }
-        int nCols = this.getColumnDimension();
-        double[] out = new double[nCols];
+        final int nCols = this.getColumnDimension();
+        final double[] out = new double[nCols];
         for (int col = 0; col < nCols; col++) {
             double sum = 0;
             for (int i = 0; i < nRows; i++) {
@@ -682,13 +822,13 @@
      * @throws InvalidMatrixException if this matrix is not square or is singular
      */
     public double[] solve(double[] b) throws IllegalArgumentException, InvalidMatrixException {
-        int nRows = this.getRowDimension();
+        final int nRows = this.getRowDimension();
         if (b.length != nRows) {
             throw new IllegalArgumentException("constant vector has wrong length");
         }
-        RealMatrix bMatrix = new RealMatrixImpl(b);
-        double[][] solution = ((RealMatrixImpl) (solve(bMatrix))).getDataRef();
-        double[] out = new double[nRows];
+        final RealMatrix bMatrix = new RealMatrixImpl(b);
+        final double[][] solution = ((RealMatrixImpl) (solve(bMatrix))).getDataRef();
+        final double[] out = new double[nRows];
         for (int row = 0; row < nRows; row++) {
             out[row] = solution[row][0];
         }
@@ -717,41 +857,48 @@
             throw new InvalidMatrixException("Matrix is singular.");
         }
 
-        int nCol = this.getColumnDimension();
-        int nColB = b.getColumnDimension();
-        int nRowB = b.getRowDimension();
+        final int nCol  = this.getColumnDimension();
+        final int nColB = b.getColumnDimension();
+        final int nRowB = b.getRowDimension();
 
         // Apply permutations to b
-        double[][] bp = new double[nRowB][nColB];
+        final double[][] bp = new double[nRowB][nColB];
         for (int row = 0; row < nRowB; row++) {
+            final double[] bpRow = bp[row];
             for (int col = 0; col < nColB; col++) {
-                bp[row][col] = b.getEntry(permutation[row], col);
+                bpRow[col] = b.getEntry(permutation[row], col);
             }
         }
 
         // Solve LY = b
         for (int col = 0; col < nCol; col++) {
             for (int i = col + 1; i < nCol; i++) {
+                final double[] bpI = bp[i];
+                final double[] luI = lu[i];
                 for (int j = 0; j < nColB; j++) {
-                    bp[i][j] -= bp[col][j] * lu[i][col];
+                    bpI[j] -= bp[col][j] * luI[col];
                 }
             }
         }
 
         // Solve UX = Y
         for (int col = nCol - 1; col >= 0; col--) {
+            final double[] bpCol = bp[col];
+            final double luDiag = lu[col][col];
             for (int j = 0; j < nColB; j++) {
-                bp[col][j] /= lu[col][col];
+                bpCol[j] /= luDiag;
             }
             for (int i = 0; i < col; i++) {
+                final double[] bpI = bp[i];
+                final double[] luI = lu[i];
                 for (int j = 0; j < nColB; j++) {
-                    bp[i][j] -= bp[col][j] * lu[i][col];
+                    bpI[j] -= bp[col][j] * luI[col];
                 }
             }
         }
 
-        RealMatrixImpl outMat = new RealMatrixImpl(bp);
-        return outMat;
+        return new RealMatrixImpl(bp, false);
+
     }
 
     /**
@@ -774,12 +921,12 @@
      */
     public void luDecompose() throws InvalidMatrixException {
 
-        int nRows = this.getRowDimension();
-        int nCols = this.getColumnDimension();
+        final int nRows = this.getRowDimension();
+        final int nCols = this.getColumnDimension();
         if (nRows != nCols) {
             throw new InvalidMatrixException("LU decomposition requires that the matrix be square.");
         }
-        lu = this.getData();
+        lu = getData();
 
         // Initialize permutation array and parity
         permutation = new int[nRows];
@@ -795,22 +942,24 @@
 
             // upper
             for (int row = 0; row < col; row++) {
-                sum = lu[row][col];
+                final double[] luRow = lu[row];
+                sum = luRow[col];
                 for (int i = 0; i < row; i++) {
-                    sum -= lu[row][i] * lu[i][col];
+                    sum -= luRow[i] * lu[i][col];
                 }
-                lu[row][col] = sum;
+                luRow[col] = sum;
             }
 
             // lower
             int max = col; // permutation row
             double largest = 0d;
             for (int row = col; row < nRows; row++) {
-                sum = lu[row][col];
+                final double[] luRow = lu[row];
+                sum = luRow[col];
                 for (int i = 0; i < col; i++) {
-                    sum -= lu[row][i] * lu[i][col];
+                    sum -= luRow[i] * lu[i][col];
                 }
-                lu[row][col] = sum;
+                luRow[col] = sum;
 
                 // maintain best permutation choice
                 if (Math.abs(sum) > largest) {
@@ -839,9 +988,10 @@
                 parity = -parity;
             }
 
-            //Divide the lower elements by the "winning" diagonal elt.
+            // Divide the lower elements by the "winning" diagonal elt.
+            final double luDiag = lu[col][col];
             for (int row = col + 1; row < nRows; row++) {
-                lu[row][col] /= lu[col][col];
+                lu[row][col] /= luDiag;
             }
         }
     }
@@ -855,12 +1005,14 @@
         res.append("RealMatrixImpl{");
         if (data != null) {
             for (int i = 0; i < data.length; i++) {
-                if (i > 0)
+                if (i > 0) {
                     res.append(",");
+                }
                 res.append("{");
                 for (int j = 0; j < data[0].length; j++) {
-                    if (j > 0)
+                    if (j > 0) {
                         res.append(",");
+                    }
                     res.append(data[i][j]);
                 } 
                 res.append("}");
@@ -887,14 +1039,15 @@
             return false;
         }
         RealMatrix m = (RealMatrix) object;
-        int nRows = getRowDimension();
-        int nCols = getColumnDimension();
+        final int nRows = getRowDimension();
+        final int nCols = getColumnDimension();
         if (m.getColumnDimension() != nCols || m.getRowDimension() != nRows) {
             return false;
         }
         for (int row = 0; row < nRows; row++) {
+            final double[] dataRow = data[row];
             for (int col = 0; col < nCols; col++) {
-                if (Double.doubleToLongBits(data[row][col]) != 
+                if (Double.doubleToLongBits(dataRow[col]) != 
                     Double.doubleToLongBits(m.getEntry(row, col))) {
                     return false;
                 }
@@ -910,14 +1063,15 @@
      */
     public int hashCode() {
         int ret = 7;
-        int nRows = getRowDimension();
-        int nCols = getColumnDimension();
+        final int nRows = getRowDimension();
+        final int nCols = getColumnDimension();
         ret = ret * 31 + nRows;
         ret = ret * 31 + nCols;
         for (int row = 0; row < nRows; row++) {
-           for (int col = 0; col < nCols; col++) {
+            final double[] dataRow = data[row];
+            for (int col = 0; col < nCols; col++) {
                ret = ret * 31 + (11 * (row+1) + 17 * (col+1)) * 
-                   MathUtils.hash(data[row][col]);
+                   MathUtils.hash(dataRow[col]);
            }
         }
         return ret;
@@ -972,7 +1126,7 @@
      * @return the permutation
      */
     protected int[] getPermutation() {
-        int[] out = new int[permutation.length];
+        final int[] out = new int[permutation.length];
         System.arraycopy(permutation, 0, out, 0, permutation.length);
         return out;
     }
@@ -985,8 +1139,8 @@
      * @return a copy of the underlying data array.
      */
     private double[][] copyOut() {
-        int nRows = this.getRowDimension();
-        double[][] out = new double[nRows][this.getColumnDimension()];
+        final int nRows = this.getRowDimension();
+        final double[][] out = new double[nRows][this.getColumnDimension()];
         // can't copy 2-d array in one shot, otherwise get row references
         for (int i = 0; i < nRows; i++) {
             System.arraycopy(data[i], 0, out[i], 0, data[i].length);
@@ -1016,9 +1170,8 @@
      * @return true if the coordinate is with the current dimensions
      */
     private boolean isValidCoordinate(int row, int col) {
-        int nRows = this.getRowDimension();
-        int nCols = this.getColumnDimension();
-
+        final int nRows = getRowDimension();
+        final int nCols = getColumnDimension();
         return !(row < 0 || row > nRows - 1 || col < 0 || col > nCols -1);
     }
 

Modified: commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml
URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml?rev=662241&r1=662240&r2=662241&view=diff
==============================================================================
--- commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml (original)
+++ commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml Sun Jun  1 09:22:19 2008
@@ -39,6 +39,10 @@
   </properties>
   <body>
     <release version="2.0" date="TBD" description="TBD">
+      <action dev="luc" type="update" >
+        Greatly improved RealMatrixImpl and BigMatrixImpl performances,
+        both in terms of speed and in terms of temporary memory footprint.
+      </action>
       <action dev="luc" type="add" issue="MATH-203" due-to="Mauro Talevi">
         Added Mauro's patch to support multiple regression.
       </action>

Modified: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/BigMatrixImplTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/BigMatrixImplTest.java?rev=662241&r1=662240&r2=662241&view=diff
==============================================================================
--- commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/BigMatrixImplTest.java (original)
+++ commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/BigMatrixImplTest.java Sun Jun  1 09:22:19 2008
@@ -156,9 +156,12 @@
     
     /** test copy functions */
     public void testCopyFunctions() {
-        BigMatrixImpl m = new BigMatrixImpl(testData);
-        BigMatrixImpl m2 = new BigMatrixImpl(m.getData());
-        assertEquals(m2,m);
+        BigMatrixImpl m1 = new BigMatrixImpl(testData);
+        BigMatrixImpl m2 = new BigMatrixImpl(m1.getData());
+        assertEquals(m2,m1);
+        BigMatrixImpl m3 = new BigMatrixImpl(testData);
+        BigMatrixImpl m4 = new BigMatrixImpl(m3.getData(), false);
+        assertEquals(m4,m3);
     }
     
     /** test constructors */
@@ -166,9 +169,13 @@
         BigMatrix m1 = new BigMatrixImpl(testData);
         BigMatrix m2 = new BigMatrixImpl(testDataString);
         BigMatrix m3 = new BigMatrixImpl(asBigDecimal(testData));
+        BigMatrix m4 = new BigMatrixImpl(asBigDecimal(testData), true);
+        BigMatrix m5 = new BigMatrixImpl(asBigDecimal(testData), false);
         assertClose("double, string", m1, m2, Double.MIN_VALUE);
         assertClose("double, BigDecimal", m1, m3, Double.MIN_VALUE);
         assertClose("string, BigDecimal", m2, m3, Double.MIN_VALUE);
+        assertClose("double, BigDecimal/true", m1, m4, Double.MIN_VALUE);
+        assertClose("double, BigDecimal/false", m1, m5, Double.MIN_VALUE);
         try {
             new BigMatrixImpl(new String[][] {{"0", "hello", "1"}});
             fail("Expecting NumberFormatException");
@@ -212,7 +219,7 @@
     public void testAdd() {
         BigMatrixImpl m = new BigMatrixImpl(testData);
         BigMatrixImpl mInv = new BigMatrixImpl(testDataInv);
-        BigMatrixImpl mPlusMInv = (BigMatrixImpl)m.add(mInv);
+        BigMatrix mPlusMInv = m.add(mInv);
         double[][] sumEntries = asDouble(mPlusMInv.getData());
         for (int row = 0; row < m.getRowDimension(); row++) {
             for (int col = 0; col < m.getColumnDimension(); col++) {

Modified: commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/MatrixUtilsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/MatrixUtilsTest.java?rev=662241&r1=662240&r2=662241&view=diff
==============================================================================
--- commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/MatrixUtilsTest.java (original)
+++ commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/linear/MatrixUtilsTest.java Sun Jun  1 09:22:19 2008
@@ -65,6 +65,10 @@
     public void testCreateRealMatrix() {
         assertEquals(new RealMatrixImpl(testData), 
                 MatrixUtils.createRealMatrix(testData));
+        assertEquals(new RealMatrixImpl(testData, false), 
+                MatrixUtils.createRealMatrix(testData, true));
+        assertEquals(new RealMatrixImpl(testData, true), 
+                MatrixUtils.createRealMatrix(testData, false));
         try {
             MatrixUtils.createRealMatrix(new double[][] {{1}, {1,2}});  // ragged
             fail("Expecting IllegalArgumentException");
@@ -88,6 +92,10 @@
     public void testCreateBigMatrix() {
         assertEquals(new BigMatrixImpl(testData), 
                 MatrixUtils.createBigMatrix(testData));
+        assertEquals(new BigMatrixImpl(BigMatrixImplTest.asBigDecimal(testData), true), 
+                MatrixUtils.createBigMatrix(BigMatrixImplTest.asBigDecimal(testData), false));
+        assertEquals(new BigMatrixImpl(BigMatrixImplTest.asBigDecimal(testData), false), 
+                MatrixUtils.createBigMatrix(BigMatrixImplTest.asBigDecimal(testData), true));
         assertEquals(new BigMatrixImpl(bigColMatrix), 
                 MatrixUtils.createBigMatrix(bigColMatrix));
         assertEquals(new BigMatrixImpl(stringColMatrix), 



Mime
View raw message