/*
    * 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
    *
    *      https://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.
   */
  
  /*
   * This is not the original file distributed by the Apache Software Foundation
   * It has been modified by the Hipparchus project
   */
  
  package org.hipparchus.linear;
  
  import java.io.Serializable;
  import org.hipparchus.Field;
  import org.hipparchus.FieldElement;
  import org.hipparchus.exception.LocalizedCoreFormats;
  import org.hipparchus.exception.MathIllegalArgumentException;
  import org.hipparchus.exception.MathIllegalStateException;
  import org.hipparchus.exception.NullArgumentException;
  import org.hipparchus.util.MathArrays;
  import org.hipparchus.util.MathUtils;
  
  /**
   * Implementation of {@link FieldMatrix} using a {@link FieldElement}[][] array to store entries.
   * <p>
   * As specified in the {@link FieldMatrix} interface, matrix element indexing
   * is 0-based -- e.g., {@code getEntry(0, 0)}
   * returns the element in the first row, first column of the matrix
   * </p>
   *
   * @param <T> the type of the field elements
   */
  public class Array2DRowFieldMatrix<T extends FieldElement<T>>
      extends AbstractFieldMatrix<T>
      implements Serializable {
      /** Serializable version identifier */
      private static final long serialVersionUID = 7260756672015356458L;
      /** Entries of the matrix */
      private T[][] data;
  
      /**
       * Creates a matrix with no data
       * @param field field to which the elements belong
       */
      public Array2DRowFieldMatrix(final Field<T> field) {
          super(field);
      }
  
      /**
       * Create a new {@code FieldMatrix<T>} with the supplied row and column dimensions.
       *
       * @param field Field to which the elements belong.
       * @param rowDimension Number of rows in the new matrix.
       * @param columnDimension Number of columns in the new matrix.
       * @throws MathIllegalArgumentException if row or column dimension is not positive.
       */
      public Array2DRowFieldMatrix(final Field<T> field, final int rowDimension,
                                   final int columnDimension)
          throws MathIllegalArgumentException {
          super(field, rowDimension, columnDimension);
          data = MathArrays.buildArray(field, rowDimension, columnDimension);
      }
  
      /**
       * Create a new {@code FieldMatrix<T>} 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 #Array2DRowFieldMatrix(FieldElement[][], boolean)}
       * with the second argument set to {@code true}.</p>
       *
       * @param d Data for the new matrix.
       * @throws MathIllegalArgumentException if {@code d} is not rectangular.
       * @throws NullArgumentException if {@code d} is {@code null}.
       * @throws MathIllegalArgumentException if there are not at least one row and one column.
       * @see #Array2DRowFieldMatrix(FieldElement[][], boolean)
       */
      public Array2DRowFieldMatrix(final T[][] d)
          throws MathIllegalArgumentException, NullArgumentException {
          this(extractField(d), d);
      }
  
      /**
       * Create a new {@code FieldMatrix<T>} 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 #Array2DRowFieldMatrix(FieldElement[][], boolean)}
       * with the second argument set to {@code true}.</p>
      *
      * @param field Field to which the elements belong.
      * @param d Data for the new matrix.
      * @throws MathIllegalArgumentException if {@code d} is not rectangular.
      * @throws NullArgumentException if {@code d} is {@code null}.
      * @throws MathIllegalArgumentException if there are not at least one row and one column.
      * @see #Array2DRowFieldMatrix(FieldElement[][], boolean)
      */
     public Array2DRowFieldMatrix(final Field<T> field, final T[][] d)
         throws MathIllegalArgumentException, NullArgumentException {
         super(field);
         copyIn(d);
     }
 
     /**
      * Create a new {@code FieldMatrix<T>} using the input array as the underlying
      * data array.
      * <p>If an array is built specially in order to be embedded in a
      * {@code FieldMatrix<T>} 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.</p>
      *
      * @param d Data for the new matrix.
      * @param copyArray Whether to copy or reference the input array.
      * @throws MathIllegalArgumentException if {@code d} is not rectangular.
      * @throws MathIllegalArgumentException if there are not at least one row and one column.
      * @throws NullArgumentException if {@code d} is {@code null}.
      * @see #Array2DRowFieldMatrix(FieldElement[][])
      */
     public Array2DRowFieldMatrix(final T[][] d, final boolean copyArray)
         throws MathIllegalArgumentException,
         NullArgumentException {
         this(extractField(d), d, copyArray);
     }
 
     /**
      * Create a new {@code FieldMatrix<T>} using the input array as the underlying
      * data array.
      * <p>If an array is built specially in order to be embedded in a
      * {@code FieldMatrix<T>} 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.</p>
      *
      * @param field Field to which the elements belong.
      * @param d Data for the new matrix.
      * @param copyArray Whether to copy or reference the input array.
      * @throws MathIllegalArgumentException if {@code d} is not rectangular.
      * @throws MathIllegalArgumentException if there are not at least one row and one column.
      * @throws NullArgumentException if {@code d} is {@code null}.
      * @see #Array2DRowFieldMatrix(FieldElement[][])
      */
     public Array2DRowFieldMatrix(final Field<T> field, final T[][] d, final boolean copyArray)
         throws MathIllegalArgumentException, NullArgumentException {
         super(field);
         if (copyArray) {
             copyIn(d);
         } else {
             MathUtils.checkNotNull(d);
             final int nRows = d.length;
             if (nRows == 0) {
                 throw new MathIllegalArgumentException(LocalizedCoreFormats.AT_LEAST_ONE_ROW);
             }
             final int nCols = d[0].length;
             if (nCols == 0) {
                 throw new MathIllegalArgumentException(LocalizedCoreFormats.AT_LEAST_ONE_COLUMN);
             }
             for (int r = 1; r < nRows; r++) {
                 if (d[r].length != nCols) {
                     throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
                                                            nCols, d[r].length);
                 }
             }
             data = d; // NOPMD - array copy is taken care of by parameter
         }
     }
 
     /**
      * Create a new (column) {@code FieldMatrix<T>} 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.
      * @throws MathIllegalArgumentException if v is empty
      */
     public Array2DRowFieldMatrix(final T[] v) throws MathIllegalArgumentException {
         this(extractField(v), v);
     }
 
     /**
      * Create a new (column) {@code FieldMatrix<T>} using {@code v} as the
      * data for the unique column of the created matrix.
      * The input array is copied.
      *
      * @param field Field to which the elements belong.
      * @param v Column vector holding data for new matrix.
      */
     public Array2DRowFieldMatrix(final Field<T> field, final T[] v) {
         super(field);
         final int nRows = v.length;
         data = MathArrays.buildArray(getField(), nRows, 1);
         for (int row = 0; row < nRows; row++) {
             data[row][0] = v[row];
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public FieldMatrix<T> createMatrix(final int rowDimension,
                                        final int columnDimension)
         throws MathIllegalArgumentException {
         return new Array2DRowFieldMatrix<T>(getField(), rowDimension, columnDimension);
     }
 
     /** {@inheritDoc} */
     @Override
     public FieldMatrix<T> copy() {
         return new Array2DRowFieldMatrix<T>(getField(), copyOut(), false);
     }
 
     /**
      * Add {@code m} to this matrix.
      *
      * @param m Matrix to be added.
      * @return {@code this} + m.
      * @throws MathIllegalArgumentException if {@code m} is not the same
      * size as this matrix.
      */
     public Array2DRowFieldMatrix<T> add(final Array2DRowFieldMatrix<T> m)
         throws MathIllegalArgumentException {
         // safety check
         checkAdditionCompatible(m);
 
         final int rowCount    = getRowDimension();
         final int columnCount = getColumnDimension();
         final T[][] outData = MathArrays.buildArray(getField(), rowCount, columnCount);
         for (int row = 0; row < rowCount; row++) {
             final T[] dataRow    = data[row];
             final T[] mRow       = m.data[row];
             final T[] outDataRow = outData[row];
             for (int col = 0; col < columnCount; col++) {
                 outDataRow[col] = dataRow[col].add(mRow[col]);
             }
         }
 
         return new Array2DRowFieldMatrix<T>(getField(), outData, false);
     }
 
     /**
      * Subtract {@code m} from this matrix.
      *
      * @param m Matrix to be subtracted.
      * @return {@code this} + m.
      * @throws MathIllegalArgumentException if {@code m} is not the same
      * size as this matrix.
      */
     public Array2DRowFieldMatrix<T> subtract(final Array2DRowFieldMatrix<T> m)
         throws MathIllegalArgumentException {
         // safety check
         checkSubtractionCompatible(m);
 
         final int rowCount    = getRowDimension();
         final int columnCount = getColumnDimension();
         final T[][] outData = MathArrays.buildArray(getField(), rowCount, columnCount);
         for (int row = 0; row < rowCount; row++) {
             final T[] dataRow    = data[row];
             final T[] mRow       = m.data[row];
             final T[] outDataRow = outData[row];
             for (int col = 0; col < columnCount; col++) {
                 outDataRow[col] = dataRow[col].subtract(mRow[col]);
             }
         }
 
         return new Array2DRowFieldMatrix<T>(getField(), outData, false);
 
     }
 
     /**
      * Postmultiplying this matrix by {@code m}.
      *
      * @param m Matrix to postmultiply by.
      * @return {@code this} * m.
      * @throws MathIllegalArgumentException if the number of columns of this
      * matrix is not equal to the number of rows of {@code m}.
      */
     public Array2DRowFieldMatrix<T> multiply(final Array2DRowFieldMatrix<T> m)
         throws MathIllegalArgumentException {
         // safety check
         checkMultiplicationCompatible(m);
 
         final int nRows = this.getRowDimension();
         final int nCols = m.getColumnDimension();
         final int nSum = this.getColumnDimension();
         final T[][] outData = MathArrays.buildArray(getField(), nRows, nCols);
         for (int row = 0; row < nRows; row++) {
             final T[] dataRow    = data[row];
             final T[] outDataRow = outData[row];
             for (int col = 0; col < nCols; col++) {
                 T sum = getField().getZero();
                 for (int i = 0; i < nSum; i++) {
                     sum = sum.add(dataRow[i].multiply(m.data[i][col]));
                 }
                 outDataRow[col] = sum;
             }
         }
 
         return new Array2DRowFieldMatrix<T>(getField(), outData, false);
 
     }
 
     /**
      * Returns the result of postmultiplying {@code this} by {@code m^T}.
      * @param m matrix to first transpose and second postmultiply by
      * @return {@code this * m^T}
      * @throws MathIllegalArgumentException if
      * {@code columnDimension(this) != columnDimension(m)}
      * @since 1.3
      */
     public FieldMatrix<T> multiplyTransposed(final Array2DRowFieldMatrix<T> m)
         throws MathIllegalArgumentException {
         MatrixUtils.checkSameColumnDimension(this, m);
 
         final int nRows = this.getRowDimension();
         final int nCols = m.getRowDimension();
         final int nSum  = this.getColumnDimension();
 
         final FieldMatrix<T> out   = MatrixUtils.createFieldMatrix(getField(), nRows, nCols);
         final T[][]          mData = m.data;
 
         // Multiply.
         for (int col = 0; col < nCols; col++) {
             for (int row = 0; row < nRows; row++) {
                 final T[] dataRow = data[row];
                 final T[] mRow    = mData[col];
                 T sum = getField().getZero();
                 for (int i = 0; i < nSum; i++) {
                     sum = sum.add(dataRow[i].multiply(mRow[i]));
                 }
                 out.setEntry(row, col, sum);
             }
         }
 
         return out;
 
     }
 
     /** {@inheritDoc} */
     @Override
     public FieldMatrix<T> multiplyTransposed(final FieldMatrix<T> m) {
         if (m instanceof Array2DRowFieldMatrix) {
             return multiplyTransposed((Array2DRowFieldMatrix<T>) m);
         } else {
             MatrixUtils.checkSameColumnDimension(this, m);
 
             final int nRows = this.getRowDimension();
             final int nCols = m.getRowDimension();
             final int nSum  = this.getColumnDimension();
 
             final FieldMatrix<T> out = MatrixUtils.createFieldMatrix(getField(), nRows, nCols);
 
             // Multiply.
             for (int col = 0; col < nCols; col++) {
                 for (int row = 0; row < nRows; row++) {
                     final T[] dataRow = data[row];
                     T sum = getField().getZero();
                     for (int i = 0; i < nSum; i++) {
                         sum = sum.add(dataRow[i].multiply(m.getEntry(col, i)));
                     }
                     out.setEntry(row, col, sum);
                 }
             }
 
             return out;
 
         }
     }
 
     /**
      * Returns the result of postmultiplying {@code this^T} by {@code m}.
      * @param m matrix to postmultiply by
      * @return {@code this^T * m}
      * @throws MathIllegalArgumentException if
      * {@code columnDimension(this) != columnDimension(m)}
      * @since 1.3
      */
     public FieldMatrix<T> transposeMultiply(final Array2DRowFieldMatrix<T> m)
         throws MathIllegalArgumentException {
         MatrixUtils.checkSameRowDimension(this, m);
 
         final int nRows = this.getColumnDimension();
         final int nCols = m.getColumnDimension();
         final int nSum  = this.getRowDimension();
 
         final FieldMatrix<T> out   = MatrixUtils.createFieldMatrix(getField(), nRows, nCols);
         final T[][]          mData = m.data;
 
         // Multiply.
         for (int k = 0; k < nSum; k++) {
             final T[] dataK = data[k];
             final T[] mK    = mData[k];
             for (int row = 0; row < nRows; row++) {
                 final T dataIRow = dataK[row];
                 for (int col = 0; col < nCols; col++) {
                     out.addToEntry(row, col, dataIRow.multiply(mK[col]));
                 }
             }
         }
 
         return out;
     }
 
     /** {@inheritDoc} */
     @Override
     public FieldMatrix<T> transposeMultiply(final FieldMatrix<T> m) {
         if (m instanceof Array2DRowFieldMatrix) {
             return transposeMultiply((Array2DRowFieldMatrix<T>) m);
         } else {
             MatrixUtils.checkSameRowDimension(this, m);
 
             final int nRows = this.getColumnDimension();
             final int nCols = m.getColumnDimension();
             final int nSum  = this.getRowDimension();
 
             final FieldMatrix<T> out = MatrixUtils.createFieldMatrix(getField(), nRows, nCols);
 
             // Multiply.
             for (int k = 0; k < nSum; k++) {
                 final T[] dataK = data[k];
                 for (int row = 0; row < nRows; row++) {
                     final T dataIRow = dataK[row];
                     for (int col = 0; col < nCols; col++) {
                         out.addToEntry(row, col, dataIRow.multiply(m.getEntry(k, col)));
                     }
                 }
             }
 
             return out;
 
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public T[][] getData() {
         return copyOut();
     }
 
     /**
      * Get a reference to the underlying data array.
      * This methods returns internal data, <strong>not</strong> fresh copy of it.
      *
      * @return the 2-dimensional array of entries.
      */
     public T[][] getDataRef() {
         return data; // NOPMD - returning an internal array is intentional and documented here
     }
 
     /** {@inheritDoc} */
     @Override
     public void setSubMatrix(final T[][] subMatrix, final int row,
                              final int column)
         throws MathIllegalArgumentException, NullArgumentException {
         if (data == null) {
             if (row > 0) {
                 throw new MathIllegalStateException(LocalizedCoreFormats.FIRST_ROWS_NOT_INITIALIZED_YET, row);
             }
             if (column > 0) {
                 throw new MathIllegalStateException(LocalizedCoreFormats.FIRST_COLUMNS_NOT_INITIALIZED_YET, column);
             }
             final int nRows = subMatrix.length;
             if (nRows == 0) {
                 throw new MathIllegalArgumentException(LocalizedCoreFormats.AT_LEAST_ONE_ROW);
             }
 
             final int nCols = subMatrix[0].length;
             if (nCols == 0) {
                 throw new MathIllegalArgumentException(LocalizedCoreFormats.AT_LEAST_ONE_COLUMN);
             }
             data = MathArrays.buildArray(getField(), subMatrix.length, nCols);
             for (int i = 0; i < data.length; ++i) {
                 if (subMatrix[i].length != nCols) {
                     throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
                                                            nCols, subMatrix[i].length);
                 }
                 System.arraycopy(subMatrix[i], 0, data[i + row], column, nCols);
             }
         } else {
             super.setSubMatrix(subMatrix, row, column);
         }
 
     }
 
     /** {@inheritDoc} */
     @Override
     public T getEntry(final int row, final int column)
         throws MathIllegalArgumentException {
       try {
         return data[row][column];
       } catch (IndexOutOfBoundsException e) {
         // throw the exact cause of the exception
         checkRowIndex(row);
         checkColumnIndex(column);
         // should never happen
         throw e;
       }
     }
 
     /** {@inheritDoc} */
     @Override
     public void setEntry(final int row, final int column, final T value)
         throws MathIllegalArgumentException {
         checkRowIndex(row);
         checkColumnIndex(column);
 
         data[row][column] = value;
     }
 
     /** {@inheritDoc} */
     @Override
     public void addToEntry(final int row, final int column, final T increment)
         throws MathIllegalArgumentException {
         checkRowIndex(row);
         checkColumnIndex(column);
 
         data[row][column] = data[row][column].add(increment);
     }
 
     /** {@inheritDoc} */
     @Override
     public void multiplyEntry(final int row, final int column, final T factor)
         throws MathIllegalArgumentException {
         checkRowIndex(row);
         checkColumnIndex(column);
 
         data[row][column] = data[row][column].multiply(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 T[] operate(final T[] v) throws MathIllegalArgumentException {
         final int nRows = this.getRowDimension();
         final int nCols = this.getColumnDimension();
         if (v.length != nCols) {
             throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
                                                    v.length, nCols);
         }
         final T[] out = MathArrays.buildArray(getField(), nRows);
         for (int row = 0; row < nRows; row++) {
             final T[] dataRow = data[row];
             T sum = getField().getZero();
             for (int i = 0; i < nCols; i++) {
                 sum = sum.add(dataRow[i].multiply(v[i]));
             }
             out[row] = sum;
         }
         return out;
     }
 
     /** {@inheritDoc} */
     @Override
     public T[] preMultiply(final T[] v) throws MathIllegalArgumentException {
         final int nRows = getRowDimension();
         final int nCols = getColumnDimension();
         if (v.length != nRows) {
             throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH,
                                                    v.length, nRows);
         }
 
         final T[] out = MathArrays.buildArray(getField(), nCols);
         for (int col = 0; col < nCols; ++col) {
             T sum = getField().getZero();
             for (int i = 0; i < nRows; ++i) {
                 sum = sum.add(data[i][col].multiply(v[i]));
             }
             out[col] = sum;
         }
 
         return out;
     }
 
     /** {@inheritDoc} */
     @Override
     public FieldMatrix<T> getSubMatrix(final int startRow, final int endRow,
                                        final int startColumn, final int endColumn)
         throws MathIllegalArgumentException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         final int rowCount = endRow - startRow + 1;
         final int columnCount = endColumn - startColumn + 1;
         final T[][] outData = MathArrays.buildArray(getField(), rowCount, columnCount);
         for (int i = 0; i < rowCount; ++i) {
             System.arraycopy(data[startRow + i], startColumn, outData[i], 0, columnCount);
         }
 
         Array2DRowFieldMatrix<T> subMatrix = new Array2DRowFieldMatrix<>(getField());
         subMatrix.data = outData;
         return subMatrix;
     }
 
     /** {@inheritDoc} */
     @Override
     public T walkInRowOrder(final FieldMatrixChangingVisitor<T> 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 T[] rowI = data[i];
             for (int j = 0; j < columns; ++j) {
                 rowI[j] = visitor.visit(i, j, rowI[j]);
             }
         }
         return visitor.end();
     }
 
     /** {@inheritDoc} */
     @Override
     public T walkInRowOrder(final FieldMatrixPreservingVisitor<T> 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 T[] rowI = data[i];
             for (int j = 0; j < columns; ++j) {
                 visitor.visit(i, j, rowI[j]);
             }
         }
         return visitor.end();
     }
 
     /** {@inheritDoc} */
     @Override
     public T walkInRowOrder(final FieldMatrixChangingVisitor<T> visitor,
                             final int startRow, final int endRow,
                             final int startColumn, final int endColumn)
         throws MathIllegalArgumentException {
         checkSubMatrixIndex(startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);
         for (int i = startRow; i <= endRow; ++i) {
             final T[] rowI = data[i];
             for (int j = startColumn; j <= endColumn; ++j) {
                 rowI[j] = visitor.visit(i, j, rowI[j]);
             }
         }
         return visitor.end();
     }
 
     /** {@inheritDoc} */
     @Override
     public T walkInRowOrder(final FieldMatrixPreservingVisitor<T> visitor,
                             final int startRow, final int endRow,
                             final int startColumn, final int endColumn)
         throws MathIllegalArgumentException {
         checkSubMatrixIndex(startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);
         for (int i = startRow; i <= endRow; ++i) {
             final T[] rowI = data[i];
             for (int j = startColumn; j <= endColumn; ++j) {
                 visitor.visit(i, j, rowI[j]);
             }
         }
         return visitor.end();
     }
 
     /** {@inheritDoc} */
     @Override
     public T walkInColumnOrder(final FieldMatrixChangingVisitor<T> 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 T[] rowI = data[i];
                 rowI[j] = visitor.visit(i, j, rowI[j]);
             }
         }
         return visitor.end();
     }
 
     /** {@inheritDoc} */
     @Override
     public T walkInColumnOrder(final FieldMatrixPreservingVisitor<T> 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 T walkInColumnOrder(final FieldMatrixChangingVisitor<T> visitor,
                                final int startRow, final int endRow,
                                final int startColumn, final int endColumn)
         throws MathIllegalArgumentException {
     checkSubMatrixIndex(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 T[] rowI = data[i];
                 rowI[j] = visitor.visit(i, j, rowI[j]);
             }
         }
         return visitor.end();
     }
 
     /** {@inheritDoc} */
     @Override
     public T walkInColumnOrder(final FieldMatrixPreservingVisitor<T> visitor,
                                final int startRow, final int endRow,
                                final int startColumn, final int endColumn)
         throws MathIllegalArgumentException {
         checkSubMatrixIndex(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 T[][] copyOut() {
         final int nRows = this.getRowDimension();
         final T[][] out = MathArrays.buildArray(getField(), nRows, 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 MathIllegalArgumentException if the input array is empty.
      * @throws MathIllegalArgumentException if the input array is not rectangular.
      * @throws NullArgumentException if the input array is {@code null}.
      */
     private void copyIn(final T[][] in)
         throws MathIllegalArgumentException, NullArgumentException {
         setSubMatrix(in, 0, 0);
     }
 
     /** {@inheritDoc} */
     @Override
     public T[] getRow(final int row) throws MathIllegalArgumentException {
         MatrixUtils.checkRowIndex(this, row);
         final int nCols = getColumnDimension();
         final T[] out = MathArrays.buildArray(getField(), nCols);
         System.arraycopy(data[row], 0, out, 0, nCols);
         return out;
     }
 
     /** {@inheritDoc} */
     @Override
     public void setRow(final int row, final T[] array)
         throws MathIllegalArgumentException {
         MatrixUtils.checkRowIndex(this, row);
         final int nCols = getColumnDimension();
         if (array.length != nCols) {
             throw new MathIllegalArgumentException(LocalizedCoreFormats.DIMENSIONS_MISMATCH_2x2,
                                                    1, array.length, 1, nCols);
         }
         System.arraycopy(array, 0, data[row], 0, nCols);
     }
 
 }