commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/linear/Array2DRowRealMatrix.java - commons-math - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.apache.commons.math4.legacy.linear;

 import java.io.Serializable;

 import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
 import org.apache.commons.math4.legacy.exception.MathIllegalStateException;
 import org.apache.commons.math4.legacy.exception.NoDataException;
 import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
 import org.apache.commons.math4.legacy.exception.NullArgumentException;
 import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
 import org.apache.commons.math4.legacy.exception.OutOfRangeException;
 import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;

 /**
  * Implementation of {@link RealMatrix} using a {@code double[][]} array to
  * store entries.
  */
 public class Array2DRowRealMatrix extends AbstractRealMatrix implements Serializable {
     /** Serializable version identifier. */
     private static final long serialVersionUID = -1067294169172445528L;

     /** Entries of the matrix. */
     private double data[][];

     /**
      * Creates a matrix with no data.
      */
     public Array2DRowRealMatrix() {}

     /**
      * Create a new RealMatrix with the supplied row and column dimensions.
      *
      * @param rowDimension Number of rows in the new matrix.
      * @param columnDimension Number of columns in the new matrix.
      * @throws NotStrictlyPositiveException if the row or column dimension is
      * not positive.
      */
     public Array2DRowRealMatrix(final int rowDimension,
                                 final int columnDimension)
         throws NotStrictlyPositiveException {
         super(rowDimension, columnDimension);
         data = new double[rowDimension][columnDimension];
     }

     /**
      * Create a new {@code RealMatrix} using the input array as the underlying
      * data array.
      * <p>The input array is copied, not referenced. This constructor has
      * the same effect as calling {@link #Array2DRowRealMatrix(double[][], boolean)}
      * with the second argument set to {@code true}.</p>
      *
      * @param d Data for the new matrix.
      * @throws DimensionMismatchException if {@code d} is not rectangular.
      * @throws NoDataException if {@code d} row or column dimension is zero.
      * @throws NullArgumentException if {@code d} is {@code null}.
      * @see #Array2DRowRealMatrix(double[][], boolean)
      */
     public Array2DRowRealMatrix(final double[][] d)
         throws DimensionMismatchException, NoDataException, NullArgumentException {
         copyIn(d);
     }

     /**
      * Create a new RealMatrix using the input array as the underlying
      * data array.
      * If an array is built specially in order to be embedded in a
      * RealMatrix and not used directly, the {@code copyArray} may be
      * set to {@code false}. This will prevent the copying and improve
      * performance as no new array will be built and no data will be copied.
      *
      * @param d Data for new matrix.
      * @param copyArray if {@code true}, the input array will be copied,
      * otherwise it will be referenced.
      * @throws DimensionMismatchException if {@code d} is not rectangular.
      * @throws NoDataException if {@code d} row or column dimension is zero.
      * @throws NullArgumentException if {@code d} is {@code null}.
      * @see #Array2DRowRealMatrix(double[][])
      */
     public Array2DRowRealMatrix(final double[][] d, final boolean copyArray)
         throws DimensionMismatchException, NoDataException,
         NullArgumentException {
         if (copyArray) {
             copyIn(d);
         } else {
             if (d == null) {
                 throw new NullArgumentException();
             }
             final int nRows = d.length;
             if (nRows == 0) {
                 throw new NoDataException(LocalizedFormats.AT_LEAST_ONE_ROW);
             }
             final int nCols = d[0].length;
             if (nCols == 0) {
                 throw new NoDataException(LocalizedFormats.AT_LEAST_ONE_COLUMN);
             }
             for (int r = 1; r < nRows; r++) {
                 if (d[r].length != nCols) {
                     throw new DimensionMismatchException(d[r].length, nCols);
                 }
             }
             data = d;
         }
     }

     /**
      * Create a new (column) RealMatrix using {@code v} as the
      * data for the unique column of the created matrix.
      * The input array is copied.
      *
      * @param v Column vector holding data for new matrix.
      */
     public Array2DRowRealMatrix(final double[] v) {
         final int nRows = v.length;
         data = new double[nRows][1];
         for (int row = 0; row < nRows; row++) {
             data[row][0] = v[row];
         }
     }

     /** {@inheritDoc} */
     @Override
     public RealMatrix createMatrix(final int rowDimension,
                                    final int columnDimension)
         throws NotStrictlyPositiveException {
         return new Array2DRowRealMatrix(rowDimension, columnDimension);
     }

     /** {@inheritDoc} */
     @Override
     public RealMatrix copy() {
         return new Array2DRowRealMatrix(copyOut(), false);
     }

     /**
      * Compute the sum of {@code this} and {@code m}.
      *
      * @param m Matrix to be added.
      * @return {@code this + m}.
      * @throws MatrixDimensionMismatchException if {@code m} is not the same
      * size as {@code this}.
      */
     public Array2DRowRealMatrix add(final Array2DRowRealMatrix m)
         throws MatrixDimensionMismatchException {
         // Safety check.
         checkAdd(m);

         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[] mRow       = m.data[row];
             final double[] outDataRow = outData[row];
             for (int col = 0; col < columnCount; col++) {
                 outDataRow[col] = dataRow[col] + mRow[col];
             }
         }

         return new Array2DRowRealMatrix(outData, false);
     }

     /**
      * Returns {@code this} minus {@code m}.
      *
      * @param m Matrix to be subtracted.
      * @return {@code this - m}
      * @throws MatrixDimensionMismatchException if {@code m} is not the same
      * size as {@code this}.
      */
     public Array2DRowRealMatrix subtract(final Array2DRowRealMatrix m)
         throws MatrixDimensionMismatchException {
         checkAdd(m);

         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[] mRow       = m.data[row];
             final double[] outDataRow = outData[row];
             for (int col = 0; col < columnCount; col++) {
                 outDataRow[col] = dataRow[col] - mRow[col];
             }
         }

         return new Array2DRowRealMatrix(outData, false);
     }

     /**
      * Returns the result of postmultiplying {@code this} by {@code m}.
      *
      * @param m matrix to postmultiply by
      * @return {@code this * m}
      * @throws DimensionMismatchException if
      * {@code columnDimension(this) != rowDimension(m)}
      */
     public Array2DRowRealMatrix multiply(final Array2DRowRealMatrix m)
         throws DimensionMismatchException {
         checkMultiply(m);

         final int nRows = this.getRowDimension();
         final int nCols = m.getColumnDimension();
         final int nSum = this.getColumnDimension();

         final double[][] outData = new double[nRows][nCols];
         // Will hold a column of "m".
         final double[] mCol = new double[nSum];
         final double[][] mData = m.data;

         // Multiply.
         for (int col = 0; col < nCols; col++) {
             // Copy all elements of column "col" of "m" so that
             // will be in contiguous memory.
             for (int mRow = 0; mRow < nSum; mRow++) {
                 mCol[mRow] = mData[mRow][col];
             }

             for (int row = 0; row < nRows; row++) {
                 final double[] dataRow = data[row];
                 double sum = 0;
                 for (int i = 0; i < nSum; i++) {
                     sum += dataRow[i] * mCol[i];
                 }
                 outData[row][col] = sum;
             }
         }

         return new Array2DRowRealMatrix(outData, false);
     }

     /** {@inheritDoc} */
     @Override
     public double[][] getData() {
         return copyOut();
     }

     /**
      * Get a reference to the underlying data array.
      *
      * @return 2-dimensional array of entries.
      */
     public double[][] getDataRef() {
         return data;
     }

     /** {@inheritDoc} */
     @Override
     public void setSubMatrix(final double[][] subMatrix, final int row,
                              final int column)
         throws NoDataException, OutOfRangeException,
         DimensionMismatchException, NullArgumentException {
         if (data == null) {
             if (row > 0) {
                 throw new MathIllegalStateException(LocalizedFormats.FIRST_ROWS_NOT_INITIALIZED_YET, row);
             }
             if (column > 0) {
                 throw new MathIllegalStateException(LocalizedFormats.FIRST_COLUMNS_NOT_INITIALIZED_YET, column);
             }
             NullArgumentException.check(subMatrix);
             final int nRows = subMatrix.length;
             if (nRows == 0) {
                 throw new NoDataException(LocalizedFormats.AT_LEAST_ONE_ROW);
             }

             final int nCols = subMatrix[0].length;
             if (nCols == 0) {
                 throw new NoDataException(LocalizedFormats.AT_LEAST_ONE_COLUMN);
             }
             data = new double[subMatrix.length][nCols];
             for (int i = 0; i < data.length; ++i) {
                 if (subMatrix[i].length != nCols) {
                     throw new DimensionMismatchException(subMatrix[i].length, nCols);
                 }
                 System.arraycopy(subMatrix[i], 0, data[i + row], column, nCols);
             }
         } else {
             super.setSubMatrix(subMatrix, row, column);
         }

     }

     /** {@inheritDoc} */
     @Override
     public double getEntry(final int row, final int column)
         throws OutOfRangeException {
         MatrixUtils.checkMatrixIndex(this, row, column);
         return data[row][column];
     }

     /** {@inheritDoc} */
     @Override
     public void setEntry(final int row, final int column, final double value)
         throws OutOfRangeException {
         MatrixUtils.checkMatrixIndex(this, row, column);
         data[row][column] = value;
     }

     /** {@inheritDoc} */
     @Override
     public void addToEntry(final int row, final int column,
                            final double increment)
         throws OutOfRangeException {
         MatrixUtils.checkMatrixIndex(this, row, column);
         data[row][column] += increment;
     }

     /** {@inheritDoc} */
     @Override
     public void multiplyEntry(final int row, final int column,
                               final double factor)
         throws OutOfRangeException {
         MatrixUtils.checkMatrixIndex(this, row, column);
         data[row][column] *= factor;
     }

     /** {@inheritDoc} */
     @Override
     public int getRowDimension() {
         return (data == null) ? 0 : data.length;
     }

     /** {@inheritDoc} */
     @Override
     public int getColumnDimension() {
         return ((data == null) || (data[0] == null)) ? 0 : data[0].length;
     }

     /** {@inheritDoc} */
     @Override
     public double[] operate(final double[] v)
         throws DimensionMismatchException {
         final int nRows = this.getRowDimension();
         final int nCols = this.getColumnDimension();
         if (v.length != nCols) {
             throw new DimensionMismatchException(v.length, nCols);
         }
         final double[] out = new double[nRows];
         for (int row = 0; row < nRows; row++) {
             final double[] dataRow = data[row];
             double sum = 0;
             for (int i = 0; i < nCols; i++) {
                 sum += dataRow[i] * v[i];
             }
             out[row] = sum;
         }
         return out;
     }

     /** {@inheritDoc} */
     @Override
     public double[] preMultiply(final double[] v)
         throws DimensionMismatchException {
         final int nRows = getRowDimension();
         final int nCols = getColumnDimension();
         if (v.length != nRows) {
             throw new DimensionMismatchException(v.length, nRows);
         }

         final double[] out = new double[nCols];
         for (int col = 0; col < nCols; ++col) {
             double sum = 0;
             for (int i = 0; i < nRows; ++i) {
                 sum += data[i][col] * v[i];
             }
             out[col] = sum;
         }

         return out;

     }

     /** {@inheritDoc} */
     @Override
     public RealMatrix getSubMatrix(final int startRow, final int endRow,
                                    final int startColumn, final int endColumn)
             throws OutOfRangeException, NumberIsTooSmallException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         final int rowCount = endRow - startRow + 1;
         final int columnCount = endColumn - startColumn + 1;
         final double[][] outData = new double[rowCount][columnCount];
         for (int i = 0; i < rowCount; ++i) {
             System.arraycopy(data[startRow + i], startColumn, outData[i], 0, columnCount);
         }

         Array2DRowRealMatrix subMatrix = new Array2DRowRealMatrix();
         subMatrix.data = outData;
         return subMatrix;
     }

     /** {@inheritDoc} */
     @Override
     public double walkInRowOrder(final RealMatrixChangingVisitor visitor) {
         final int rows    = getRowDimension();
         final int columns = getColumnDimension();
         visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
         for (int i = 0; i < rows; ++i) {
             final double[] rowI = data[i];
             for (int j = 0; j < columns; ++j) {
                 rowI[j] = visitor.visit(i, j, rowI[j]);
             }
         }
         return visitor.end();
     }

     /** {@inheritDoc} */
     @Override
     public double walkInRowOrder(final RealMatrixPreservingVisitor visitor) {
         final int rows    = getRowDimension();
         final int columns = getColumnDimension();
         visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
         for (int i = 0; i < rows; ++i) {
             final double[] rowI = data[i];
             for (int j = 0; j < columns; ++j) {
                 visitor.visit(i, j, rowI[j]);
             }
         }
         return visitor.end();
     }

     /** {@inheritDoc} */
     @Override
     public double walkInRowOrder(final RealMatrixChangingVisitor visitor,
                                  final int startRow, final int endRow,
                                  final int startColumn, final int endColumn)
         throws OutOfRangeException, NumberIsTooSmallException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);
         for (int i = startRow; i <= endRow; ++i) {
             final double[] rowI = data[i];
             for (int j = startColumn; j <= endColumn; ++j) {
                 rowI[j] = visitor.visit(i, j, rowI[j]);
             }
         }
         return visitor.end();
     }

     /** {@inheritDoc} */
     @Override
     public double walkInRowOrder(final RealMatrixPreservingVisitor visitor,
                                  final int startRow, final int endRow,
                                  final int startColumn, final int endColumn)
         throws OutOfRangeException, NumberIsTooSmallException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);
         for (int i = startRow; i <= endRow; ++i) {
             final double[] rowI = data[i];
             for (int j = startColumn; j <= endColumn; ++j) {
                 visitor.visit(i, j, rowI[j]);
             }
         }
         return visitor.end();
     }

     /** {@inheritDoc} */
     @Override
     public double walkInColumnOrder(final RealMatrixChangingVisitor visitor) {
         final int rows    = getRowDimension();
         final int columns = getColumnDimension();
         visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
         for (int j = 0; j < columns; ++j) {
             for (int i = 0; i < rows; ++i) {
                 final double[] rowI = data[i];
                 rowI[j] = visitor.visit(i, j, rowI[j]);
             }
         }
         return visitor.end();
     }

     /** {@inheritDoc} */
     @Override
     public double walkInColumnOrder(final RealMatrixPreservingVisitor visitor) {
         final int rows    = getRowDimension();
         final int columns = getColumnDimension();
         visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
         for (int j = 0; j < columns; ++j) {
             for (int i = 0; i < rows; ++i) {
                 visitor.visit(i, j, data[i][j]);
             }
         }
         return visitor.end();
     }

     /** {@inheritDoc} */
     @Override
     public double walkInColumnOrder(final RealMatrixChangingVisitor visitor,
                                     final int startRow, final int endRow,
                                     final int startColumn, final int endColumn)
         throws OutOfRangeException, NumberIsTooSmallException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);
         for (int j = startColumn; j <= endColumn; ++j) {
             for (int i = startRow; i <= endRow; ++i) {
                 final double[] rowI = data[i];
                 rowI[j] = visitor.visit(i, j, rowI[j]);
             }
         }
         return visitor.end();
     }

     /** {@inheritDoc} */
     @Override
     public double walkInColumnOrder(final RealMatrixPreservingVisitor visitor,
                                     final int startRow, final int endRow,
                                     final int startColumn, final int endColumn)
         throws OutOfRangeException, NumberIsTooSmallException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);
         for (int j = startColumn; j <= endColumn; ++j) {
             for (int i = startRow; i <= endRow; ++i) {
                 visitor.visit(i, j, data[i][j]);
             }
         }
         return visitor.end();
     }

     /**
      * Get a fresh copy of the underlying data array.
      *
      * @return a copy of the underlying data array.
      */
     private double[][] copyOut() {
         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);
         }
         return out;
     }

     /**
      * Replace data with a fresh copy of the input array.
      *
      * @param in Data to copy.
      * @throws NoDataException if the input array is empty.
      * @throws DimensionMismatchException if the input array is not rectangular.
      * @throws NullArgumentException if the input array is {@code null}.
      */
     private void copyIn(final double[][] in)
         throws DimensionMismatchException, NoDataException, NullArgumentException {
         setSubMatrix(in, 0, 0);
     }

     /** {@inheritDoc} */
     @Override
     public double[] getRow(final int row)
         throws OutOfRangeException {
         MatrixUtils.checkRowIndex(this, row);
         final int nCols = getColumnDimension();
         final double[] out = new double[nCols];
         System.arraycopy(data[row], 0, out, 0, nCols);
         return out;
     }

     /** {@inheritDoc} */
     @Override
     public void setRow(final int row,
                        final double[] array)
         throws OutOfRangeException, MatrixDimensionMismatchException {
         MatrixUtils.checkRowIndex(this, row);
         final int nCols = getColumnDimension();
         if (array.length != nCols) {
                 throw new MatrixDimensionMismatchException(1, array.length, 1, nCols);
         }
         System.arraycopy(array, 0, data[row], 0, nCols);
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.apache.commons.math4.legacy.linear;

	import java.io.Serializable;

	import org.apache.commons.math4.legacy.exception.DimensionMismatchException;
	import org.apache.commons.math4.legacy.exception.MathIllegalStateException;
	import org.apache.commons.math4.legacy.exception.NoDataException;
	import org.apache.commons.math4.legacy.exception.NotStrictlyPositiveException;
	import org.apache.commons.math4.legacy.exception.NullArgumentException;
	import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException;
	import org.apache.commons.math4.legacy.exception.OutOfRangeException;
	import org.apache.commons.math4.legacy.exception.util.LocalizedFormats;

	/**
	* Implementation of {@link RealMatrix} using a {@code double[][]} array to
	* store entries.
	*/
	public class Array2DRowRealMatrix extends AbstractRealMatrix implements Serializable {
	/** Serializable version identifier. */
	private static final long serialVersionUID = -1067294169172445528L;

	/** Entries of the matrix. */
	private double data[][];

	/**
	* Creates a matrix with no data.
	*/
	public Array2DRowRealMatrix() {}

	/**
	* Create a new RealMatrix with the supplied row and column dimensions.
	*
	* @param rowDimension Number of rows in the new matrix.
	* @param columnDimension Number of columns in the new matrix.
	* @throws NotStrictlyPositiveException if the row or column dimension is
	* not positive.
	*/
	public Array2DRowRealMatrix(final int rowDimension,
	final int columnDimension)
	throws NotStrictlyPositiveException {
	super(rowDimension, columnDimension);
	data = new double[rowDimension][columnDimension];
	}

	/**
	* Create a new {@code RealMatrix} using the input array as the underlying
	* data array.
	* <p>The input array is copied, not referenced. This constructor has
	* the same effect as calling {@link #Array2DRowRealMatrix(double[][], boolean)}
	* with the second argument set to {@code true}.</p>
	*
	* @param d Data for the new matrix.
	* @throws DimensionMismatchException if {@code d} is not rectangular.
	* @throws NoDataException if {@code d} row or column dimension is zero.
	* @throws NullArgumentException if {@code d} is {@code null}.
	* @see #Array2DRowRealMatrix(double[][], boolean)
	*/
	public Array2DRowRealMatrix(final double[][] d)
	throws DimensionMismatchException, NoDataException, NullArgumentException {
	copyIn(d);
	}

	/**
	* Create a new RealMatrix using the input array as the underlying
	* data array.
	* If an array is built specially in order to be embedded in a
	* RealMatrix and not used directly, the {@code copyArray} may be
	* set to {@code false}. This will prevent the copying and improve
	* performance as no new array will be built and no data will be copied.
	*
	* @param d Data for new matrix.
	* @param copyArray if {@code true}, the input array will be copied,
	* otherwise it will be referenced.
	* @throws DimensionMismatchException if {@code d} is not rectangular.
	* @throws NoDataException if {@code d} row or column dimension is zero.
	* @throws NullArgumentException if {@code d} is {@code null}.
	* @see #Array2DRowRealMatrix(double[][])
	*/
	public Array2DRowRealMatrix(final double[][] d, final boolean copyArray)
	throws DimensionMismatchException, NoDataException,
	NullArgumentException {
	if (copyArray) {
	copyIn(d);
	} else {
	if (d == null) {
	throw new NullArgumentException();
	}
	final int nRows = d.length;
	if (nRows == 0) {
	throw new NoDataException(LocalizedFormats.AT_LEAST_ONE_ROW);
	}
	final int nCols = d[0].length;
	if (nCols == 0) {
	throw new NoDataException(LocalizedFormats.AT_LEAST_ONE_COLUMN);
	}
	for (int r = 1; r < nRows; r++) {
	if (d[r].length != nCols) {
	throw new DimensionMismatchException(d[r].length, nCols);
	}
	}
	data = d;
	}
	}

	/**
	* Create a new (column) RealMatrix using {@code v} as the
	* data for the unique column of the created matrix.
	* The input array is copied.
	*
	* @param v Column vector holding data for new matrix.
	*/
	public Array2DRowRealMatrix(final double[] v) {
	final int nRows = v.length;
	data = new double[nRows][1];
	for (int row = 0; row < nRows; row++) {
	data[row][0] = v[row];
	}
	}

	/** {@inheritDoc} */
	@Override
	public RealMatrix createMatrix(final int rowDimension,
	final int columnDimension)
	throws NotStrictlyPositiveException {
	return new Array2DRowRealMatrix(rowDimension, columnDimension);
	}

	/** {@inheritDoc} */
	@Override
	public RealMatrix copy() {
	return new Array2DRowRealMatrix(copyOut(), false);
	}

	/**
	* Compute the sum of {@code this} and {@code m}.
	*
	* @param m Matrix to be added.
	* @return {@code this + m}.
	* @throws MatrixDimensionMismatchException if {@code m} is not the same
	* size as {@code this}.
	*/
	public Array2DRowRealMatrix add(final Array2DRowRealMatrix m)
	throws MatrixDimensionMismatchException {
	// Safety check.
	checkAdd(m);

	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[] mRow = m.data[row];
	final double[] outDataRow = outData[row];
	for (int col = 0; col < columnCount; col++) {
	outDataRow[col] = dataRow[col] + mRow[col];
	}
	}

	return new Array2DRowRealMatrix(outData, false);
	}

	/**
	* Returns {@code this} minus {@code m}.
	*
	* @param m Matrix to be subtracted.
	* @return {@code this - m}
	* @throws MatrixDimensionMismatchException if {@code m} is not the same
	* size as {@code this}.
	*/
	public Array2DRowRealMatrix subtract(final Array2DRowRealMatrix m)
	throws MatrixDimensionMismatchException {
	checkAdd(m);

	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[] mRow = m.data[row];
	final double[] outDataRow = outData[row];
	for (int col = 0; col < columnCount; col++) {
	outDataRow[col] = dataRow[col] - mRow[col];
	}
	}

	return new Array2DRowRealMatrix(outData, false);
	}

	/**
	* Returns the result of postmultiplying {@code this} by {@code m}.
	*
	* @param m matrix to postmultiply by
	* @return {@code this * m}
	* @throws DimensionMismatchException if
	* {@code columnDimension(this) != rowDimension(m)}
	*/
	public Array2DRowRealMatrix multiply(final Array2DRowRealMatrix m)
	throws DimensionMismatchException {
	checkMultiply(m);

	final int nRows = this.getRowDimension();
	final int nCols = m.getColumnDimension();
	final int nSum = this.getColumnDimension();

	final double[][] outData = new double[nRows][nCols];
	// Will hold a column of "m".
	final double[] mCol = new double[nSum];
	final double[][] mData = m.data;

	// Multiply.
	for (int col = 0; col < nCols; col++) {
	// Copy all elements of column "col" of "m" so that
	// will be in contiguous memory.
	for (int mRow = 0; mRow < nSum; mRow++) {
	mCol[mRow] = mData[mRow][col];
	}

	for (int row = 0; row < nRows; row++) {
	final double[] dataRow = data[row];
	double sum = 0;
	for (int i = 0; i < nSum; i++) {
	sum += dataRow[i] * mCol[i];
	}
	outData[row][col] = sum;
	}
	}

	return new Array2DRowRealMatrix(outData, false);
	}

	/** {@inheritDoc} */
	@Override
	public double[][] getData() {
	return copyOut();
	}

	/**
	* Get a reference to the underlying data array.
	*
	* @return 2-dimensional array of entries.
	*/
	public double[][] getDataRef() {
	return data;
	}

	/** {@inheritDoc} */
	@Override
	public void setSubMatrix(final double[][] subMatrix, final int row,
	final int column)
	throws NoDataException, OutOfRangeException,
	DimensionMismatchException, NullArgumentException {
	if (data == null) {
	if (row > 0) {
	throw new MathIllegalStateException(LocalizedFormats.FIRST_ROWS_NOT_INITIALIZED_YET, row);
	}
	if (column > 0) {
	throw new MathIllegalStateException(LocalizedFormats.FIRST_COLUMNS_NOT_INITIALIZED_YET, column);
	}
	NullArgumentException.check(subMatrix);
	final int nRows = subMatrix.length;
	if (nRows == 0) {
	throw new NoDataException(LocalizedFormats.AT_LEAST_ONE_ROW);
	}

	final int nCols = subMatrix[0].length;
	if (nCols == 0) {
	throw new NoDataException(LocalizedFormats.AT_LEAST_ONE_COLUMN);
	}
	data = new double[subMatrix.length][nCols];
	for (int i = 0; i < data.length; ++i) {
	if (subMatrix[i].length != nCols) {
	throw new DimensionMismatchException(subMatrix[i].length, nCols);
	}
	System.arraycopy(subMatrix[i], 0, data[i + row], column, nCols);
	}
	} else {
	super.setSubMatrix(subMatrix, row, column);
	}

	}

	/** {@inheritDoc} */
	@Override
	public double getEntry(final int row, final int column)
	throws OutOfRangeException {
	MatrixUtils.checkMatrixIndex(this, row, column);
	return data[row][column];
	}

	/** {@inheritDoc} */
	@Override
	public void setEntry(final int row, final int column, final double value)
	throws OutOfRangeException {
	MatrixUtils.checkMatrixIndex(this, row, column);
	data[row][column] = value;
	}

	/** {@inheritDoc} */
	@Override
	public void addToEntry(final int row, final int column,
	final double increment)
	throws OutOfRangeException {
	MatrixUtils.checkMatrixIndex(this, row, column);
	data[row][column] += increment;
	}

	/** {@inheritDoc} */
	@Override
	public void multiplyEntry(final int row, final int column,
	final double factor)
	throws OutOfRangeException {
	MatrixUtils.checkMatrixIndex(this, row, column);
	data[row][column] *= factor;
	}

	/** {@inheritDoc} */
	@Override
	public int getRowDimension() {
	return (data == null) ? 0 : data.length;
	}

	/** {@inheritDoc} */
	@Override
	public int getColumnDimension() {
	return ((data == null) \|\| (data[0] == null)) ? 0 : data[0].length;
	}

	/** {@inheritDoc} */
	@Override
	public double[] operate(final double[] v)
	throws DimensionMismatchException {
	final int nRows = this.getRowDimension();
	final int nCols = this.getColumnDimension();
	if (v.length != nCols) {
	throw new DimensionMismatchException(v.length, nCols);
	}
	final double[] out = new double[nRows];
	for (int row = 0; row < nRows; row++) {
	final double[] dataRow = data[row];
	double sum = 0;
	for (int i = 0; i < nCols; i++) {
	sum += dataRow[i] * v[i];
	}
	out[row] = sum;
	}
	return out;
	}

	/** {@inheritDoc} */
	@Override
	public double[] preMultiply(final double[] v)
	throws DimensionMismatchException {
	final int nRows = getRowDimension();
	final int nCols = getColumnDimension();
	if (v.length != nRows) {
	throw new DimensionMismatchException(v.length, nRows);
	}

	final double[] out = new double[nCols];
	for (int col = 0; col < nCols; ++col) {
	double sum = 0;
	for (int i = 0; i < nRows; ++i) {
	sum += data[i][col] * v[i];
	}
	out[col] = sum;
	}

	return out;

	}

	/** {@inheritDoc} */
	@Override
	public RealMatrix getSubMatrix(final int startRow, final int endRow,
	final int startColumn, final int endColumn)
	throws OutOfRangeException, NumberIsTooSmallException {
	MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
	final int rowCount = endRow - startRow + 1;
	final int columnCount = endColumn - startColumn + 1;
	final double[][] outData = new double[rowCount][columnCount];
	for (int i = 0; i < rowCount; ++i) {
	System.arraycopy(data[startRow + i], startColumn, outData[i], 0, columnCount);
	}

	Array2DRowRealMatrix subMatrix = new Array2DRowRealMatrix();
	subMatrix.data = outData;
	return subMatrix;
	}

	/** {@inheritDoc} */
	@Override
	public double walkInRowOrder(final RealMatrixChangingVisitor visitor) {
	final int rows = getRowDimension();
	final int columns = getColumnDimension();
	visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
	for (int i = 0; i < rows; ++i) {
	final double[] rowI = data[i];
	for (int j = 0; j < columns; ++j) {
	rowI[j] = visitor.visit(i, j, rowI[j]);
	}
	}
	return visitor.end();
	}

	/** {@inheritDoc} */
	@Override
	public double walkInRowOrder(final RealMatrixPreservingVisitor visitor) {
	final int rows = getRowDimension();
	final int columns = getColumnDimension();
	visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
	for (int i = 0; i < rows; ++i) {
	final double[] rowI = data[i];
	for (int j = 0; j < columns; ++j) {
	visitor.visit(i, j, rowI[j]);
	}
	}
	return visitor.end();
	}

	/** {@inheritDoc} */
	@Override
	public double walkInRowOrder(final RealMatrixChangingVisitor visitor,
	final int startRow, final int endRow,
	final int startColumn, final int endColumn)
	throws OutOfRangeException, NumberIsTooSmallException {
	MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
	visitor.start(getRowDimension(), getColumnDimension(),
	startRow, endRow, startColumn, endColumn);
	for (int i = startRow; i <= endRow; ++i) {
	final double[] rowI = data[i];
	for (int j = startColumn; j <= endColumn; ++j) {
	rowI[j] = visitor.visit(i, j, rowI[j]);
	}
	}
	return visitor.end();
	}

	/** {@inheritDoc} */
	@Override
	public double walkInRowOrder(final RealMatrixPreservingVisitor visitor,
	final int startRow, final int endRow,
	final int startColumn, final int endColumn)
	throws OutOfRangeException, NumberIsTooSmallException {
	MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
	visitor.start(getRowDimension(), getColumnDimension(),
	startRow, endRow, startColumn, endColumn);
	for (int i = startRow; i <= endRow; ++i) {
	final double[] rowI = data[i];
	for (int j = startColumn; j <= endColumn; ++j) {
	visitor.visit(i, j, rowI[j]);
	}
	}
	return visitor.end();
	}

	/** {@inheritDoc} */
	@Override
	public double walkInColumnOrder(final RealMatrixChangingVisitor visitor) {
	final int rows = getRowDimension();
	final int columns = getColumnDimension();
	visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
	for (int j = 0; j < columns; ++j) {
	for (int i = 0; i < rows; ++i) {
	final double[] rowI = data[i];
	rowI[j] = visitor.visit(i, j, rowI[j]);
	}
	}
	return visitor.end();
	}

	/** {@inheritDoc} */
	@Override
	public double walkInColumnOrder(final RealMatrixPreservingVisitor visitor) {
	final int rows = getRowDimension();
	final int columns = getColumnDimension();
	visitor.start(rows, columns, 0, rows - 1, 0, columns - 1);
	for (int j = 0; j < columns; ++j) {
	for (int i = 0; i < rows; ++i) {
	visitor.visit(i, j, data[i][j]);
	}
	}
	return visitor.end();
	}

	/** {@inheritDoc} */
	@Override
	public double walkInColumnOrder(final RealMatrixChangingVisitor visitor,
	final int startRow, final int endRow,
	final int startColumn, final int endColumn)
	throws OutOfRangeException, NumberIsTooSmallException {
	MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
	visitor.start(getRowDimension(), getColumnDimension(),
	startRow, endRow, startColumn, endColumn);
	for (int j = startColumn; j <= endColumn; ++j) {
	for (int i = startRow; i <= endRow; ++i) {
	final double[] rowI = data[i];
	rowI[j] = visitor.visit(i, j, rowI[j]);
	}
	}
	return visitor.end();
	}

	/** {@inheritDoc} */
	@Override
	public double walkInColumnOrder(final RealMatrixPreservingVisitor visitor,
	final int startRow, final int endRow,
	final int startColumn, final int endColumn)
	throws OutOfRangeException, NumberIsTooSmallException {
	MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
	visitor.start(getRowDimension(), getColumnDimension(),
	startRow, endRow, startColumn, endColumn);
	for (int j = startColumn; j <= endColumn; ++j) {
	for (int i = startRow; i <= endRow; ++i) {
	visitor.visit(i, j, data[i][j]);
	}
	}
	return visitor.end();
	}

	/**
	* Get a fresh copy of the underlying data array.
	*
	* @return a copy of the underlying data array.
	*/
	private double[][] copyOut() {
	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);
	}
	return out;
	}

	/**
	* Replace data with a fresh copy of the input array.
	*
	* @param in Data to copy.
	* @throws NoDataException if the input array is empty.
	* @throws DimensionMismatchException if the input array is not rectangular.
	* @throws NullArgumentException if the input array is {@code null}.
	*/
	private void copyIn(final double[][] in)
	throws DimensionMismatchException, NoDataException, NullArgumentException {
	setSubMatrix(in, 0, 0);
	}

	/** {@inheritDoc} */
	@Override
	public double[] getRow(final int row)
	throws OutOfRangeException {
	MatrixUtils.checkRowIndex(this, row);
	final int nCols = getColumnDimension();
	final double[] out = new double[nCols];
	System.arraycopy(data[row], 0, out, 0, nCols);
	return out;
	}

	/** {@inheritDoc} */
	@Override
	public void setRow(final int row,
	final double[] array)
	throws OutOfRangeException, MatrixDimensionMismatchException {
	MatrixUtils.checkRowIndex(this, row);
	final int nCols = getColumnDimension();
	if (array.length != nCols) {
	throw new MatrixDimensionMismatchException(1, array.length, 1, nCols);
	}
	System.arraycopy(array, 0, data[row], 0, nCols);
	}
	}