AbstractRealMatrix (patrimoine de base SIRIUS 4.11 API)

java.lang.Object
- fr.cnes.sirius.patrius.math.linear.RealLinearOperator
- - fr.cnes.sirius.patrius.math.linear.AbstractRealMatrix

All Implemented Interfaces:

AnyMatrix, RealMatrix, Serializable

Direct Known Subclasses:

Array2DRowRealMatrix, ArrayRowSymmetricMatrix, BlockRealMatrix, DecomposedSymmetricPositiveMatrix, DiagonalMatrix
```
public abstract class AbstractRealMatrix
extends RealLinearOperator
implements RealMatrix
```
Basic implementation of RealMatrix methods regardless of the underlying storage.
All the methods implemented here use getEntry(int, int) to access matrix elements. Derived class can provide faster implementations.

This class is up-to-date with commons-math 3.6.1.

Since:

2.0

Version:

$Id: AbstractRealMatrix.java 18108 2017-10-04 06:45:27Z bignon $

See Also:

Serialized Form

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AbstractRealMatrix()` Creates a matrix with no data.
`protected`	`AbstractRealMatrix(double[][] data)` Creates a new matrix using the supplied data array.
`protected`	`AbstractRealMatrix(int rowDimension, int columnDimension)` Creates a new matrix with the supplied row and column dimensions.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`RealMatrix`	`add(RealMatrix m)` Returns the result of adding the matrix `m` to this matrix.
`void`	`addToEntry(int row, int column, double increment)` Adds (in place) a given value to the specified entry of this matrix.
`protected static void`	`checkDestinationArray(int nbRows, int nbColumns, double[][] destination, int startRowDest, int startColumnDest)` Ensures the destination array is not `null`, and large enough to store the data of a submatrix.
`protected void`	`checkSquare()` Checks if this is a square matrix and throws an exception if that's not the case.
`RealMatrix`	`concatenateDiagonally(RealMatrix m)` Diagonally concatenates this matrix and another matrix `m`, placing it in the lower right part of the concatenated matrix.
`RealMatrix`	`concatenateDiagonally(RealMatrix m, boolean lowerRightConcatenation)` Diagonally concatenates this matrix and another matrix `m`, placing it in the lower right or upper left part of the concatenated matrix.
`RealMatrix`	`concatenateDiagonally(RealMatrix m, boolean rightConcatenation, boolean lowerConcatenation)` Diagonally or anti-diagonally concatenates this matrix and another matrix `m`.
`RealMatrix`	`concatenateHorizontally(RealMatrix m)` Horizontally concatenates this matrix and another matrix `m`, placing it in the right part of the concatenated matrix.
`RealMatrix`	`concatenateHorizontally(RealMatrix m, boolean rightConcatenation)` Horizontally concatenates this matrix and another matrix `m`, , placing it in the left or right part of the concatenated matrix.
`RealMatrix`	`concatenateVertically(RealMatrix m)` Vertically concatenates this matrix and another matrix `m`, placing it in the lower part of the concatenated matrix.
`RealMatrix`	`concatenateVertically(RealMatrix m, boolean lowerConcatenation)` Vertically concatenates this matrix and another matrix `m`, placing it in the lower or upper part of the concatenated matrix.
`abstract RealMatrix`	`copy()` Returns a deep copy of this matrix.
`void`	`copySubMatrix(int[] selectedRows, int[] selectedColumns, double[][] destination)` Copies a submatrix into a given 2D array.
`void`	`copySubMatrix(int[] selectedRows, int[] selectedColumns, double[][] destination, int startRowDest, int startColumnDest)` Copies a submatrix into a given 2D array.
`void`	`copySubMatrix(int startRow, int endRow, int startColumn, int endColumn, double[][] destination)` Copies a submatrix into a given 2D array.
`void`	`copySubMatrix(int startRow, int endRow, int startColumn, int endColumn, double[][] destination, int startRowDest, int startColumnDest)` Copies a submatrix into a given 2D array.
`abstract RealMatrix`	`createMatrix(int rowDimension, int columnDimension)` Creates a new matrix of the same type as this matrix.
`boolean`	`equals(Object object)` Returns `true` if the provided object is a RealMatrix instance with the same dimensions as this matrix, whose entries are strictly equal to the entries of this matrix (no absolute or relative tolerance is taken into account when comparing the entries).
`boolean`	`equals(RealMatrix m, double relativeThreshold, double absoluteThreshold)` Is this matrix numerically equivalent to another matrix?
`double[]`	`getColumn(int column)` Gets the entries of a given column.
`abstract int`	`getColumnDimension()` Returns the dimension of the domain of this operator.
`RealMatrix`	`getColumnMatrix(int column)` Gets the entries of a given column as a column matrix.
`RealVector`	`getColumnVector(int column)` Gets the entries of a given column as a vector.
`double[][]`	`getData()` Returns a 2D array containing the entries of the matrix.
`double[][]`	`getData(boolean forceCopy)` Returns a 2D array containing the entries of the matrix.
`Function<RealMatrix,Decomposition>`	`getDefaultDecomposition()` Gets the decomposition builder the `getInverse()` method uses by default when computing the inverse of the matrix.
`double[]`	`getDiagonal()` Gets the diagonal vector from this matrix.
`abstract double`	`getEntry(int row, int column)` Gets the entry at the specified row and column.
`double`	`getFrobeniusNorm()` Returns the Frobenius norm of the matrix.
`RealMatrix`	`getInverse()` Gets the inverse (or pseudo-inverse) of this matrix using the default decomposition.
`RealMatrix`	`getInverse(Function<RealMatrix,Decomposition> decompositionBuilder)` Gets the inverse (or pseudo-inverse) of this matrix using the given decomposition algorithm.
`double`	`getMax()` Returns the maximum value of the matrix.
`double`	`getMin()` Returns the minimum value of the matrix.
`double`	`getNorm()` Returns the maximum absolute row sum norm of the matrix.
`double[]`	`getRow(int row)` Gets the entries of a given row.
`abstract int`	`getRowDimension()` Returns the dimension of the codomain of this operator.
`RealMatrix`	`getRowMatrix(int row)` Gets the entries of a given row as a row matrix.
`RealVector`	`getRowVector(int row)` Gets the entries of a given row as a vector.
`RealMatrix`	`getSubMatrix(int[] selectedRows, int[] selectedColumns)` Gets a submatrix.
`RealMatrix`	`getSubMatrix(int startRow, int endRow, int startColumn, int endColumn)` Gets a submatrix.
`double`	`getTrace()` Returns the trace of the matrix (the sum of the elements on the main diagonal).
`int`	`hashCode()` Computes a hash code for the matrix.
`boolean`	`isAntisymmetric(double relativeTolerance, double absoluteTolerance)` Is this a antisymmetric matrix?
`boolean`	`isDiagonal(double absoluteTolerance)` Is this a diagonal matrix?
`boolean`	`isInvertible(double relativeTolerance)` Is this an invertible matrix?
`boolean`	`isOrthogonal(double normalityThreshold, double orthogonalityThreshold)` Is this an orthogonal matrix?
`boolean`	`isSquare()` Is this a square matrix?
`boolean`	`isSymmetric()` Is this a symmetric matrix?
`boolean`	`isSymmetric(double relativeTolerance)` Is this a symmetric matrix?
`boolean`	`isSymmetric(double relativeTolerance, double absoluteTolerance)` Is this a symmetric matrix?
`RealMatrix`	`multiply(DiagonalMatrix m, double d)` Returns the result of postmultiplying this matrix by the diagonal matrix `m`, then by the scalar `d`.
`RealMatrix`	`multiply(RealMatrix m)` Returns the result of postmultiplying this matrix by the matrix `m`.
`RealMatrix`	`multiply(RealMatrix m, boolean toTranspose)` Returns the result of postmultiplying this matrix by the matrix `m` or its transpose `m`^T.
`RealMatrix`	`multiply(RealMatrix m, boolean toTranspose, double d)` Returns the result of postmultiplying this matrix by the matrix `m` or its transpose `m`^T, then by the scalar `d`.
`void`	`multiplyEntry(int row, int column, double factor)` Multiplies (in place) the specified entry of `this` matrix by a given value.
`double[]`	`operate(double[] v)` Returns the result of postmultiplying this matrix by the vector `v`.
`RealVector`	`operate(RealVector v)` Returns the result of multiplying `this` by the vector `x`.
`RealMatrix`	`power(int p)` Returns the the result of multiplying this matrix with itself `p` times.
`double[]`	`preMultiply(double[] v)` Returns the result of premultiplying this matrix by the vector `v`.
`RealMatrix`	`preMultiply(RealMatrix m)` Returns the result of premultiplying this matrix by the matrix `m`.
`RealVector`	`preMultiply(RealVector v)` Returns the result of premultiplying this matrix by the vector `v`.
`RealMatrix`	`scalarAdd(double d)` Returns the result of adding a scalar `d` to the entries of this matrix.
`RealMatrix`	`scalarMultiply(double d)` Returns the result of multiplying the entries of this matrix by the scalar `d`.
`void`	`setColumn(int column, double[] array)` Replaces the entries of a given column with the entries of the specified data array.
`void`	`setColumnMatrix(int column, RealMatrix matrix)` Replaces the entries of a given column with the entries of the specified column matrix.
`void`	`setColumnVector(int column, RealVector vector)` Replaces the entries of a given column with the entries of the specified vector.
`void`	`setDefaultDecomposition(Function<RealMatrix,Decomposition> defaultDecompositionBuilder)` Sets the decomposition builder the `getInverse()` method should use by default when computing the inverse of the matrix.
`abstract void`	`setEntry(int row, int column, double value)` Sets the entry at the specified row and column to a new value.
`void`	`setRow(int row, double[] array)` Replaces the entries of a given row with the entries of the specified data array.
`void`	`setRowMatrix(int row, RealMatrix matrix)` Replaces the entries of a given row with the entries of the specified row matrix.
`void`	`setRowVector(int row, RealVector vector)` Replaces the entries of a given row with the entries of the specified vector.
`void`	`setSubMatrix(double[][] subMatrix, int row, int column)` Replaces part of the matrix with a given submatrix, starting at the specified row and column.
`RealMatrix`	`subtract(RealMatrix m)` Returns the result of subtracting the matrix `m` from this matrix.
`String`	`toString()` Get a string representation for this matrix.
`String`	`toString(RealMatrixFormat realMatrixFormat)` Gets a string representation of this matrix using the specified format.
`RealMatrix`	`transpose()` Returns the transpose of this matrix.
`RealMatrix`	`transpose(boolean forceCopy)` Returns the transpose of this matrix.
`double`	`walkInColumnOrder(RealMatrixChangingVisitor visitor)` Visits (and possibly change) all matrix entries in column order.
`double`	`walkInColumnOrder(RealMatrixChangingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)` Visits (and possibly change) some matrix entries in column order.
`double`	`walkInColumnOrder(RealMatrixPreservingVisitor visitor)` Visits (but don't change) all matrix entries in column order.
`double`	`walkInColumnOrder(RealMatrixPreservingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)` Visits (but don't change) some matrix entries in column order.
`double`	`walkInOptimizedOrder(RealMatrixChangingVisitor visitor)` Visits (and possibly change) all matrix entries using the fastest possible order.
`double`	`walkInOptimizedOrder(RealMatrixChangingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)` Visits (and possibly change) some matrix entries using the fastest possible order.
`double`	`walkInOptimizedOrder(RealMatrixPreservingVisitor visitor)` Visits (but don't change) all matrix entries using the fastest possible order.
`double`	`walkInOptimizedOrder(RealMatrixPreservingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)` Visits (but don't change) some matrix entries using the fastest possible order.
`double`	`walkInRowOrder(RealMatrixChangingVisitor visitor)` Visits (and possibly change) all matrix entries in row order.
`double`	`walkInRowOrder(RealMatrixChangingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)` Visits (and possibly change) some matrix entries in row order.
`double`	`walkInRowOrder(RealMatrixPreservingVisitor visitor)` Visits (but don't change) all matrix entries in row order.
`double`	`walkInRowOrder(RealMatrixPreservingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)` Visits (but don't change) some matrix entries in row order.

Methods inherited from class fr.cnes.sirius.patrius.math.linear.RealLinearOperator
isTransposable, operateTranspose

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - AbstractRealMatrix
```
protected AbstractRealMatrix()
```
    Creates a matrix with no data.
  - AbstractRealMatrix
```
protected AbstractRealMatrix(int rowDimension,
                             int columnDimension)
```
    Creates a new matrix with the supplied row and column dimensions.
    
    Parameters:
    
    rowDimension - the number of rows in the matrix
    
    columnDimension - the number of columns in the matrix
    
    Throws:
    
    NotStrictlyPositiveException - if the row/column dimensions are not strictly positive
  - AbstractRealMatrix
```
protected AbstractRealMatrix(double[][] data)
```
    Creates a new matrix using the supplied data array.
    
    Parameters:
    
    data - the data array containing the entries of the matrix
    
    Throws:
    
    NullArgumentException - if the data array is null
    
    NoDataException - if the data array is empty
    
    DimensionMismatchException - if the rows of the data array do not have a constant number of columns
- Method Detail
  - checkSquare
```
protected void checkSquare()
```
    Checks if this is a square matrix and throws an exception if that's not the case.
    
    Throws:
    
    NonSquareMatrixException - if this is not a square matrix
  - add
```
public RealMatrix add(RealMatrix m)
```
    Returns the result of adding the matrix m to this matrix.
    
    Specified by:
    
    add in interface RealMatrix
    
    Parameters:
    
    m - the matrix to be added
    
    Returns:
    
    the matrix resulting from the addition this+m
  - subtract
```
public RealMatrix subtract(RealMatrix m)
```
    Returns the result of subtracting the matrix m from this matrix.
    
    Specified by:
    
    subtract in interface RealMatrix
    
    Parameters:
    
    m - the matrix to be subtracted
    
    Returns:
    
    the matrix resulting from the subtraction this-m
  - scalarAdd
```
public RealMatrix scalarAdd(double d)
```
    Returns the result of adding a scalar d to the entries of this matrix.
    
    Specified by:
    
    scalarAdd in interface RealMatrix
    
    Parameters:
    
    d - the scalar value to be added to the entries of this matrix
    
    Returns:
    
    the matrix resulting from the addition this+d
  - scalarMultiply
```
public RealMatrix scalarMultiply(double d)
```
    Returns the result of multiplying the entries of this matrix by the scalar d.
    
    Specified by:
    
    scalarMultiply in interface RealMatrix
    
    Parameters:
    
    d - the scalar value by which to multiply the entries of this matrix by
    
    Returns:
    
    the matrix resulting from the product this×d
  - multiply
```
public RealMatrix multiply(RealMatrix m)
```
    Returns the result of postmultiplying this matrix by the matrix m.
    
    Specified by:
    
    multiply in interface RealMatrix
    
    Parameters:
    
    m - the matrix by which to postmultiply this matrix by
    
    Returns:
    
    the matrix resulting from the product this×m
  - multiply
```
public RealMatrix multiply(RealMatrix m,
                           boolean toTranspose)
```
    Returns the result of postmultiplying this matrix by the matrix m or its transpose m^T.
    
    Specified by:
    
    multiply in interface RealMatrix
    
    Parameters:
    
    m - the matrix by which to postmultiply this matrix by
    
    toTranspose - whether to compute the product this×m (toTranspose=false ), or the product this×m^T (toTranspose=true)
    
    Returns:
    
    the matrix resulting from the product this×m or this ×m^T
  - multiply
```
public RealMatrix multiply(RealMatrix m,
                           boolean toTranspose,
                           double d)
```
    Returns the result of postmultiplying this matrix by the matrix m or its transpose m^T, then by the scalar d.
    
    Specified by:
    
    multiply in interface RealMatrix
    
    Parameters:
    
    m - the matrix by which to multiply this matrix by
    
    toTranspose - whether to compute the product this×m×d ( toTranspose=false), or the product this×m ^T×d (toTranspose=true)
    
    d - the scalar by which to multiply the resulting matrix by
    
    Returns:
    
    the matrix resulting from the product this×m×d or this×m^T×d
  - multiply
```
public RealMatrix multiply(DiagonalMatrix m,
                           double d)
```
    Returns the result of postmultiplying this matrix by the diagonal matrix m, then by the scalar d.
    
    Parameters:
    
    m - the diagonal matrix by which to multiply this matrix by
    
    d - the scalar by which to multiply the resulting matrix by
    
    Returns:
    
    the matrix resulting from the product this×m×d or this×m^T×d
    
    Throws:
    
    DimensionMismatchException - if the matrices are not multiplication compatible
  - preMultiply
```
public RealMatrix preMultiply(RealMatrix m)
```
    Returns the result of premultiplying this matrix by the matrix m.
    
    Specified by:
    
    preMultiply in interface RealMatrix
    
    Parameters:
    
    m - the matrix M by which to premultiply this matrix by
    
    Returns:
    
    the matrix resulting from the product m×this
  - operate
```
public double[] operate(double[] v)
```
    Returns the result of postmultiplying this matrix by the vector v.
    
    Specified by:
    
    operate in interface RealMatrix
    
    Parameters:
    
    v - the vector by which to multiply this matrix by
    
    Returns:
    
    the column vector resulting from the product this×v
  - operate
```
public RealVector operate(RealVector v)
```
    Returns the result of multiplying this by the vector x.
    
    Specified by:
    
    operate in interface RealMatrix
    
    Specified by:
    
    operate in class RealLinearOperator
    
    Parameters:
    
    v - the vector to operate on
    
    Returns:
    
    the product of this instance with x
  - preMultiply
```
public double[] preMultiply(double[] v)
```
    Returns the result of premultiplying this matrix by the vector v.
    
    Specified by:
    
    preMultiply in interface RealMatrix
    
    Parameters:
    
    v - the row vector by which to premultiply this matrix by
    
    Returns:
    
    the row vector resulting from the product v×this
  - preMultiply
```
public RealVector preMultiply(RealVector v)
```
    Returns the result of premultiplying this matrix by the vector v.
    
    Specified by:
    
    preMultiply in interface RealMatrix
    
    Parameters:
    
    v - the vector by which to premultiply this matrix by
    
    Returns:
    
    the row vector resulting from the product v×this
  - power
```
public RealMatrix power(int p)
```
    Returns the the result of multiplying this matrix with itself p times.
    The exponent p must be positive or equal to zero.
    This operation is only supported for square matrices.
    Depending on the underlying storage, numerical instabilities might occur for high powers.
    
    Specified by:
    
    power in interface RealMatrix
    
    Parameters:
    
    p - the exponent p to which this matrix is to be raised
    
    Returns:
    
    the matrix resulting from raising this matrix to the power of p
  - getData
```
public double[][] getData()
```
    Returns a 2D array containing the entries of the matrix.
    
    Specified by:
    
    getData in interface RealMatrix
    
    Returns:
    
    a 2D array containing the entries of the matrix
  - getData
```
public double[][] getData(boolean forceCopy)
```
    Returns a 2D array containing the entries of the matrix.
    If forceCopy is true, the returned array is guaranteed to be free of references to any internal data array (thus, can be safely modified). Otherwise, the returned array may contain references to internal data arrays (for optimization purposes). Note that setting forceCopy to false does not guarantee the returned array references an internal data array. For instance, implementations that do not store the entries of the matrix in a 2D array have to rebuild a new array each time this method is called, regardless of this parameter.
    
    Specified by:
    
    getData in interface RealMatrix
    
    Parameters:
    
    forceCopy - if true, the entries of the matrix are systematically stored in a new array; otherwise the returned array may reference internal data arrays
    
    Returns:
    
    a 2D array containing entries of the matrix
  - getDiagonal
```
public double[] getDiagonal()
```
    Gets the diagonal vector from this matrix.
    Note: The matrix needs to be square.
    
    Specified by:
    
    getDiagonal in interface RealMatrix
    
    Returns:
    
    the diagonal vector from this matrix
  - getNorm
```
public double getNorm()
```
    Returns the maximum absolute row sum norm of the matrix.
    
    Specified by:
    
    getNorm in interface RealMatrix
    
    Returns:
    
    the maximum absolute row sum norm of the matrix
  - getFrobeniusNorm
```
public double getFrobeniusNorm()
```
    Returns the Frobenius norm of the matrix.
    
    Specified by:
    
    getFrobeniusNorm in interface RealMatrix
    
    Returns:
    
    the Frobenius norm of the matrix
  - getTrace
```
public double getTrace()
```
    Returns the trace of the matrix (the sum of the elements on the main diagonal).
    The trace of the matrix is only defined for square matrices.
    
    Specified by:
    
    getTrace in interface RealMatrix
    
    Returns:
    
    the trace of the matrix
  - getMax
```
public double getMax()
```
    Returns the maximum value of the matrix.
    
    Specified by:
    
    getMax in interface RealMatrix
    
    Returns:
    
    the maximum value of the matrix
  - getMin
```
public double getMin()
```
    Returns the minimum value of the matrix.
    
    Specified by:
    
    getMin in interface RealMatrix
    
    Returns:
    
    the minimum value of the matrix
  - getSubMatrix
```
public RealMatrix getSubMatrix(int startRow,
                               int endRow,
                               int startColumn,
                               int endColumn)
```
    Gets a submatrix.
    Rows and columns are indicated counting from 0 to n-1.
    
    Specified by:
    
    getSubMatrix in interface RealMatrix
    
    Parameters:
    
    startRow - the initial row index
    
    endRow - the final row index (inclusive)
    
    startColumn - the initial column index
    
    endColumn - the final column index (inclusive)
    
    Returns:
    
    the submatrix containing the data of the specified rows and columns
  - getSubMatrix
```
public RealMatrix getSubMatrix(int[] selectedRows,
                               int[] selectedColumns)
```
    Gets a submatrix.
    Rows and columns are indicated counting from 0 to n-1.
    
    Specified by:
    
    getSubMatrix in interface RealMatrix
    
    Parameters:
    
    selectedRows - the selected row indices
    
    selectedColumns - the selected column indices
    
    Returns:
    
    the submatrix containing the data in the specified rows and columns
  - copySubMatrix
```
public void copySubMatrix(int startRow,
                          int endRow,
                          int startColumn,
                          int endColumn,
                          double[][] destination)
```
    Copies a submatrix into a given 2D array.
    Rows and columns are indicated counting from 0 to n-1. The submatrix data is copied in the upper-left part of the destination array. Elements which are not overwritten by the submatrix data are left unchanged (for example, if the destination array is larger than the size of the extracted submatrix).
    
    Specified by:
    
    copySubMatrix in interface RealMatrix
    
    Parameters:
    
    startRow - the initial row index
    
    endRow - the final row index (inclusive)
    
    startColumn - the initial column index
    
    endColumn - the final column index (inclusive)
    
    destination - the 2D array where the submatrix data should be copied
  - copySubMatrix
```
public void copySubMatrix(int startRow,
                          int endRow,
                          int startColumn,
                          int endColumn,
                          double[][] destination,
                          int startRowDest,
                          int startColumnDest)
```
    Copies a submatrix into a given 2D array.
    Rows and columns are indicated counting from 0 to n-1. The submatrix data is copied in the upper-left part of the destination array, starting at the specified row/column indices. Elements which are not overwritten by the submatrix data are left unchanged (for example, if the destination array is larger than the size of the extracted submatrix).
    
    Specified by:
    
    copySubMatrix in interface RealMatrix
    
    Parameters:
    
    startRow - the initial row index
    
    endRow - the final row index (inclusive)
    
    startColumn - the initial column index
    
    endColumn - the final column index (inclusive)
    
    destination - the 2D array where the submatrix data should be copied
    
    startRowDest - the initial row index of the destination array
    
    startColumnDest - the initial column index of the destination array
  - copySubMatrix
```
public void copySubMatrix(int[] selectedRows,
                          int[] selectedColumns,
                          double[][] destination)
```
    Copies a submatrix into a given 2D array.
    Rows and columns are indicated counting from 0 to n-1. The submatrix data is copied in the upper-left part of the destination array. Elements which are not overwritten by the submatrix data are left unchanged (for example, if the destination array is larger than the size of the extracted submatrix).
    
    Specified by:
    
    copySubMatrix in interface RealMatrix
    
    Parameters:
    
    selectedRows - the selected row indices
    
    selectedColumns - the selected column indices
    
    destination - the 2D array where the submatrix data should be copied
  - copySubMatrix
```
public void copySubMatrix(int[] selectedRows,
                          int[] selectedColumns,
                          double[][] destination,
                          int startRowDest,
                          int startColumnDest)
```
    Copies a submatrix into a given 2D array.
    Rows and columns are indicated counting from 0 to n-1. The submatrix data is copied in the upper-left part of the destination array, starting at the specified row/column indices. Elements which are not overwritten by the submatrix data are left unchanged (for example, if the destination array is larger than the size of the extracted submatrix).
    
    Specified by:
    
    copySubMatrix in interface RealMatrix
    
    Parameters:
    
    selectedRows - the selected row indices
    
    selectedColumns - the selected column indices
    
    destination - the 2D array where the submatrix data should be copied
    
    startRowDest - the initial row index of the destination array
    
    startColumnDest - the initial column index of the destination array
  - checkDestinationArray
```
protected static void checkDestinationArray(int nbRows,
                                            int nbColumns,
                                            double[][] destination,
                                            int startRowDest,
                                            int startColumnDest)
```
    Ensures the destination array is not null, and large enough to store the data of a submatrix.
    
    Parameters:
    
    nbRows - the number of rows of the extracted submatrix
    
    nbColumns - the number of columns of the extracted submatrix
    
    destination - the 2D array where the submatrix data is to be copied
    
    startRowDest - the initial row index in the destination array
    
    startColumnDest - the initial column index in the destination array
    
    Throws:
    
    NullArgumentException - if the destination array is null, or if any of the rows which will store the submatrix data is null
    
    OutOfRangeException - if the initial or final index is not a valid index for the destination array
    
    MatrixDimensionMismatchException - if the destination array is not large enough to store the submatrix data
  - setSubMatrix
```
public void setSubMatrix(double[][] subMatrix,
                         int row,
                         int column)
```
    Replaces part of the matrix with a given submatrix, starting at the specified row and column.
    Rows and columns are indicated counting from 0 to n-1.
    
    Usage example:
```
 // Initial matrix
 matrix = [a₀₀, a₁₀, a₂₀]
          [a₁₀, a₁₁, a₂₁]
          [a₂₀, a₂₁, a₂₂]
 // Submatrix
 subMatrix = [b₀₀, b₀₁]
             [b₁₀, b₁₁]
            
 // Replace part of the initial matrix 
 matrix.setSubMatrix(subMatrix, 1, 1) =>[a₀₀, a₁₀, a₂₀]
                                        [a₁₀, b₀₀, b₀₁]
                                        [a₂₀, b₁₀, b₁₁]
 
```
    Specified by:
    
    setSubMatrix in interface RealMatrix
    
    Parameters:
    
    subMatrix - the array containing the submatrix replacement data
    
    row - the row coordinate of the top, left element to be replaced
    
    column - the column coordinate of the top, left element to be replaced
  - getRowMatrix
```
public RealMatrix getRowMatrix(int row)
```
    Gets the entries of a given row as a row matrix.
    Row indices start at 0.
    
    Specified by:
    
    getRowMatrix in interface RealMatrix
    
    Parameters:
    
    row - the index of the row to be fetched
    
    Returns:
    
    the extracted row matrix
  - setRowMatrix
```
public void setRowMatrix(int row,
                         RealMatrix matrix)
```
    Replaces the entries of a given row with the entries of the specified row matrix.
    Row indices start at 0.
    The provided matrix must have one row and the same number of columns as this matrix.
    
    Specified by:
    
    setRowMatrix in interface RealMatrix
    
    Parameters:
    
    row - the index of the row to be replaced
    
    matrix - the row matrix to be copied
  - getColumnMatrix
```
public RealMatrix getColumnMatrix(int column)
```
    Gets the entries of a given column as a column matrix.
    Column indices start at 0.
    
    Specified by:
    
    getColumnMatrix in interface RealMatrix
    
    Parameters:
    
    column - the index of the column to be fetched
    
    Returns:
    
    the extracted column matrix
  - setColumnMatrix
```
public void setColumnMatrix(int column,
                            RealMatrix matrix)
```
    Replaces the entries of a given column with the entries of the specified column matrix.
    Column indices start at 0.
    The provided matrix must have one column and the same number of rows as this matrix.
    
    Specified by:
    
    setColumnMatrix in interface RealMatrix
    
    Parameters:
    
    column - the index of the column to be replaced
    
    matrix - the column matrix to be copied
  - getRowVector
```
public RealVector getRowVector(int row)
```
    Gets the entries of a given row as a vector.
    Row indices start at 0.
    
    Specified by:
    
    getRowVector in interface RealMatrix
    
    Parameters:
    
    row - the index of the row to be fetched
    
    Returns:
    
    the extracted row vector
  - setRowVector
```
public void setRowVector(int row,
                         RealVector vector)
```
    Replaces the entries of a given row with the entries of the specified vector.
    Row indices start at 0.
    The size of the provided vector must match the column dimension of this matrix.
    
    Specified by:
    
    setRowVector in interface RealMatrix
    
    Parameters:
    
    row - the index of the row to be replaced
    
    vector - the row vector to be copied
  - getColumnVector
```
public RealVector getColumnVector(int column)
```
    Gets the entries of a given column as a vector.
    Column indices start at 0.
    
    Specified by:
    
    getColumnVector in interface RealMatrix
    
    Parameters:
    
    column - the index of the column to be fetched
    
    Returns:
    
    the extracted column vector
  - setColumnVector
```
public void setColumnVector(int column,
                            RealVector vector)
```
    Replaces the entries of a given column with the entries of the specified vector.
    Column indices start at 0.
    The size of the provided vector must match the row dimension of this matrix.
    
    Specified by:
    
    setColumnVector in interface RealMatrix
    
    Parameters:
    
    column - the index of the column to be replaced
    
    vector - the column vector to be copied
  - getRow
```
public double[] getRow(int row)
```
    Gets the entries of a given row.
    Row indices start at 0.
    
    Specified by:
    
    getRow in interface RealMatrix
    
    Parameters:
    
    row - the index of the row to be fetched
    
    Returns:
    
    the extracted row data
  - setRow
```
public void setRow(int row,
                   double[] array)
```
    Replaces the entries of a given row with the entries of the specified data array.
    Row indices start at 0.
    The size of the provided data array must match the column dimension of this matrix.
    
    Specified by:
    
    setRow in interface RealMatrix
    
    Parameters:
    
    row - the index of the row to be replaced
    
    array - the row data array to be copied
  - getColumn
```
public double[] getColumn(int column)
```
    Gets the entries of a given column.
    Column indices start at 0.
    
    Specified by:
    
    getColumn in interface RealMatrix
    
    Parameters:
    
    column - the index of the column to be fetched
    
    Returns:
    
    the extracted column data
  - setColumn
```
public void setColumn(int column,
                      double[] array)
```
    Replaces the entries of a given column with the entries of the specified data array.
    Column indices start at 0.
    The size of the provided data array must match the row dimension of this matrix.
    
    Specified by:
    
    setColumn in interface RealMatrix
    
    Parameters:
    
    column - the index of the column to be replaced
    
    array - the column data array to be copied
  - addToEntry
```
public void addToEntry(int row,
                       int column,
                       double increment)
```
    Adds (in place) a given value to the specified entry of this matrix.
    Row and column indices start at 0.
    
    Specified by:
    
    addToEntry in interface RealMatrix
    
    Parameters:
    
    row - the row index of the entry to be modified
    
    column - the column index of the entry to be modified
    
    increment - the value to add to the matrix entry
  - multiplyEntry
```
public void multiplyEntry(int row,
                          int column,
                          double factor)
```
    Multiplies (in place) the specified entry of this matrix by a given value.
    Row and column indices start at 0.
    
    Specified by:
    
    multiplyEntry in interface RealMatrix
    
    Parameters:
    
    row - the row index of the entry to be modified
    
    column - the column index of the entry to be modified
    
    factor - the multiplication factor for the matrix entry
  - transpose
```
public RealMatrix transpose()
```
    Returns the transpose of this matrix.
    
    Specified by:
    
    transpose in interface RealMatrix
    
    Returns:
    
    the transpose of this matrix
  - transpose
```
public RealMatrix transpose(boolean forceCopy)
```
    Returns the transpose of this matrix.
    If forceCopy is true, the returned matrix is guaranteed to be a new instance, which can be modified without any risk of impacting the current instance. Otherwise, this method may simply return the current instance when the matrix is its own transpose (symmetric matrix).
    
    Specified by:
    
    transpose in interface RealMatrix
    
    Parameters:
    
    forceCopy - if true, the transpose of the matrix is systematically stored in a new matrix; otherwise the method may return the current instance when the matrix is its own transpose
    
    Returns:
    
    the transpose of this matrix
  - concatenateHorizontally
```
public RealMatrix concatenateHorizontally(RealMatrix m)
```
    Horizontally concatenates this matrix and another matrix m, placing it in the right part of the concatenated matrix.
    
    Specified by:
    
    concatenateHorizontally in interface RealMatrix
    
    Parameters:
    
    m - the matrix to be concatenated with this matrix
    
    Returns:
    
    the concatenated matrix
  - concatenateHorizontally
```
public RealMatrix concatenateHorizontally(RealMatrix m,
                                          boolean rightConcatenation)
```
    Horizontally concatenates this matrix and another matrix m, , placing it in the left or right part of the concatenated matrix.
    The way the two matrices are concatenated depends on the provided argument:
    The matrix m is placed in the right part of the concatenated matrix if rightConcatenation is set to true, and in its left part if it is set to false.
    
    Usage examples:
```
 this.concatenateHorizontally(m, true)  => [this, m] 
 
 this.concatenateHorizontally(m, false) => [m, this]
 
```
    Specified by:
    
    concatenateHorizontally in interface RealMatrix
    
    Parameters:
    
    m - the matrix to be concatenated with this matrix
    
    rightConcatenation - whether the matrix m is to be placed in the right (true) or left ( false) part of the concatenated matrix
    
    Returns:
    
    the concatenated matrix
  - concatenateVertically
```
public RealMatrix concatenateVertically(RealMatrix m)
```
    Vertically concatenates this matrix and another matrix m, placing it in the lower part of the concatenated matrix.
    
    Specified by:
    
    concatenateVertically in interface RealMatrix
    
    Parameters:
    
    m - the matrix to be concatenated with this matrix
    
    Returns:
    
    the concatenated matrix
  - concatenateVertically
```
public RealMatrix concatenateVertically(RealMatrix m,
                                        boolean lowerConcatenation)
```
    Vertically concatenates this matrix and another matrix m, placing it in the lower or upper part of the concatenated matrix.
    The way the two matrices are concatenated depends on the provided argument:
    The matrix m is placed in the lower part of the concatenated matrix if lowerConcatenation is set to true, and in its upper part if it is set to false.
    
    Usage examples:
```
 this.concatenateVertically(m, true)  => [this] 
                                         [   m]
                                              
 this.concatenateVertically(m, false) => [   m]
                                         [this]
 
```
    Specified by:
    
    concatenateVertically in interface RealMatrix
    
    Parameters:
    
    m - the matrix to be concatenated with this matrix
    
    lowerConcatenation - whether the matrix m is to be placed in the lower (true) or upper ( false) part of the concatenated matrix
    
    Returns:
    
    the concatenated matrix
  - concatenateDiagonally
```
public RealMatrix concatenateDiagonally(RealMatrix m)
```
    Diagonally concatenates this matrix and another matrix m, placing it in the lower right part of the concatenated matrix.
    
    Specified by:
    
    concatenateDiagonally in interface RealMatrix
    
    Parameters:
    
    m - the matrix to be concatenated with this matrix
    
    Returns:
    
    the concatenated matrix
  - concatenateDiagonally
```
public RealMatrix concatenateDiagonally(RealMatrix m,
                                        boolean lowerRightConcatenation)
```
    Diagonally concatenates this matrix and another matrix m, placing it in the lower right or upper left part of the concatenated matrix.
    The way the two matrices are concatenated depends on the provided argument:
    The matrix m is placed in the lower right part of the concatenated matrix if lowerRightConcatenation is set to true, and in its upper left part if it is set to false.
    
    Usage examples:
```
 this.concatenateDiagonally(m, true)  => [this, 0] 
                                         [   0, m]
    
 this.concatenateDiagonally(m, false) => [m,    0]
                                         [0, this]
 
```
    Specified by:
    
    concatenateDiagonally in interface RealMatrix
    
    Parameters:
    
    m - the matrix to be concatenated with this matrix
    
    lowerRightConcatenation - whether the matrix m is to be placed in the lower right (true) or upper left (false) part of the concatenated matrix
    
    Returns:
    
    the concatenated matrix
  - concatenateDiagonally
```
public RealMatrix concatenateDiagonally(RealMatrix m,
                                        boolean rightConcatenation,
                                        boolean lowerConcatenation)
```
    Diagonally or anti-diagonally concatenates this matrix and another matrix m.
    The way the two matrices are concatenated depends on the provided arguments:
    The matrix m is placed in the right part of the concatenated matrix if rightConcatenation is set to true, and in its left part if it is set to false. Similarly, the matrix m is placed in the lower part of the concatenated matrix if lowerConcatenation is set to true, and in its upper part if it is set to false. This matrix is then placed in the opposite part of the concatenated matrix (as an example, if the provided matrix is placed in the upper left part, this matrix will be placed in the lower right part, the remaining parts being filled with zeros).
    
    Usage examples:
```
 // Diagonal concatenation
 this.concatenateDiagonally(m, true, true)   => [this, 0] 
                                                [   0, m]
                                              
 this.concatenateDiagonally(m, false, false) => [m,    0]
                                                [0, this]
                          
 // Anti-diagonal concatenation
 this.concatenateDiagonally(m, false, true)  => [0, this]
                                                [m,    0]
                                               
 this.concatenateDiagonally(m, true, false)  => [   0, m]
                                                [this, 0]
 
```
    Specified by:
    
    concatenateDiagonally in interface RealMatrix
    
    Parameters:
    
    m - the matrix to be concatenated with this matrix
    
    rightConcatenation - whether the matrix m is to be placed in the right (true) or left ( false) part of the concatenated matrix
    
    lowerConcatenation - whether the matrix m is to be placed in the lower (true) or upper ( false) part of the concatenated matrix
    
    Returns:
    
    the concatenated matrix
  - setDefaultDecomposition
```
public void setDefaultDecomposition(Function<RealMatrix,Decomposition> defaultDecompositionBuilder)
```
    Sets the decomposition builder the getInverse() method should use by default when computing the inverse of the matrix.
    
    Specified by:
    
    setDefaultDecomposition in interface RealMatrix
    
    Parameters:
    
    defaultDecompositionBuilder - the default decomposition builder
  - getDefaultDecomposition
```
public Function<RealMatrix,Decomposition> getDefaultDecomposition()
```
    Gets the decomposition builder the getInverse() method uses by default when computing the inverse of the matrix.
    Unless overridden by calling setDefaultDecomposition(Function), the default decomposition is a LU decomposition with a singularity threshold of .
    
    Specified by:
    
    getDefaultDecomposition in interface RealMatrix
    
    Returns:
    
    the default decomposition builder
  - getInverse
```
public RealMatrix getInverse()
```
    Gets the inverse (or pseudo-inverse) of this matrix using the default decomposition.
    The default decomposition builder can be changed using the setDefaultDecomposition method.
    
    Specified by:
    
    getInverse in interface RealMatrix
    
    Returns:
    
    the inverse matrix
    
    See Also:
    
    RealMatrix.getDefaultDecomposition(), RealMatrix.setDefaultDecomposition(Function)
  - getInverse
```
public RealMatrix getInverse(Function<RealMatrix,Decomposition> decompositionBuilder)
```
    Gets the inverse (or pseudo-inverse) of this matrix using the given decomposition algorithm.
    The decomposition builder is a function capable of generating new instances of the decomposition algorithm to be used for the computation of the inverse matrix (like the QRDecomposition or the EigenDecomposition, for instance).
    
    Specified by:
    
    getInverse in interface RealMatrix
    
    Parameters:
    
    decompositionBuilder - the decomposition builder to use
    
    Returns:
    
    the inverse matrix
  - isSquare
```
public boolean isSquare()
```
    Is this a square matrix?
    
    Specified by:
    
    isSquare in interface AnyMatrix
    
    Returns:
    
    true if the matrix is square (rowDimension = columnDimension)
  - isOrthogonal
```
public boolean isOrthogonal(double normalityThreshold,
                            double orthogonalityThreshold)
```
    Is this an orthogonal matrix?
    This method indicates if this matrix is orthogonal, taking into account the specified tolerances.
    To do so, the method checks if the columns of the matrix form an orthonormal set (that is, the column vectors are orthogonal to each other and their norm is numerically equal to 1).
    
    This method systematically returns false for non-square matrices.
    
    Specified by:
    
    isOrthogonal in interface RealMatrix
    
    Parameters:
    
    normalityThreshold - the relative tolerance to take into account when checking the normality of the the column vectors
    
    orthogonalityThreshold - the absolute tolerance to take into account when checking the mutual orthogonality of the the column vectors
    
    Returns:
    
    true if this is an orthogonal matrix, false otherwise
  - isDiagonal
```
public boolean isDiagonal(double absoluteTolerance)
```
    Is this a diagonal matrix?
    This method indicates if the matrix is diagonal, taking into account the specified tolerance.
    To do so, the method checks if the off-diagonal elements are numerically equal to zero.
    
    This method systematically returns false for non-square matrices.
    
    Specified by:
    
    isDiagonal in interface RealMatrix
    
    Parameters:
    
    absoluteTolerance - the absolute threshold above which the absolute value of an off-diagonal element is considered to be strictly positive
    
    Returns:
    
    true if this is a diagonal matrix, false otherwise
  - isInvertible
```
public boolean isInvertible(double relativeTolerance)
```
    Is this an invertible matrix?
    This method indicates if the matrix is invertible, taking into account the specified tolerance.
    To do so, the method checks the linear independence between the column vectors of the matrix. Two columns are considered to be linearly dependent if their dot product is numerically equal to the product of their norm.
    
    This method systematically returns false for non-square matrices.
    
    Specified by:
    
    isInvertible in interface RealMatrix
    
    Parameters:
    
    relativeTolerance - the relative tolerance to take into account when checking the independence of the column vectors
    
    Returns:
    
    true if this is an invertible matrix, false otherwise
  - isSymmetric
```
public boolean isSymmetric()
```
    Is this a symmetric matrix?
    This method indicates if the matrix is symmetric.
    To do so, the method checks that symmetric off-diagonal elements are numerically equal. Two elements are considered to have different values if their absolute and relative differences are both above the default tolerances.
    
    This method systematically returns false for non-square matrices.
    
    The absolute and relative tolerances both default to Precision.DOUBLE_COMPARISON_EPSILON.
    
    Specified by:
    
    isSymmetric in interface RealMatrix
    
    Returns:
    
    true if this is a symmetric matrix, false otherwise
  - isSymmetric
```
public boolean isSymmetric(double relativeTolerance)
```
    Is this a symmetric matrix?
    This method indicates if the matrix is symmetric.
    To do so, the method checks that symmetric off-diagonal elements are numerically equal. Two elements are considered to have different values if their relative difference is above the specified tolerance.
    
    This method systematically returns false for non-square matrices.
    
    Specified by:
    
    isSymmetric in interface RealMatrix
    
    Parameters:
    
    relativeTolerance - the relative tolerance to take into account when comparing off-diagonal elements
    
    Returns:
    
    true if this is a symmetric matrix, false otherwise
  - isSymmetric
```
public boolean isSymmetric(double relativeTolerance,
                           double absoluteTolerance)
```
    Is this a symmetric matrix?
    This method indicates if the matrix is symmetric.
    To do so, the method checks that symmetric off-diagonal elements are numerically equal. Two elements are considered to have different values if their absolute and relative differences are both above the specified tolerances.
    
    This method systematically returns false for non-square matrices.
    
    Specified by:
    
    isSymmetric in interface RealMatrix
    
    Parameters:
    
    relativeTolerance - the relative tolerance to take into account when comparing off-diagonal elements
    
    absoluteTolerance - the absolute tolerance to take into account when comparing off-diagonal elements
    
    Returns:
    
    true if this is a symmetric matrix, false otherwise
  - isAntisymmetric
```
public boolean isAntisymmetric(double relativeTolerance,
                               double absoluteTolerance)
```
    Is this a antisymmetric matrix?
    This method indicates if the matrix is antisymmetric.
    To do so, the method checks that symmetric off-diagonal elements have numerically equal values but opposite signs, and that diagonal elements are numerically equal to zero. Two off-diagonal elements are considered to have different values if their absolute and relative differences are both above the specified tolerances. Diagonal elements are considered to be different from zero if their absolute value is greater than the specified absolute tolerance.
    
    This method systematically returns false for non-square matrices.
    
    Specified by:
    
    isAntisymmetric in interface RealMatrix
    
    Parameters:
    
    relativeTolerance - the relative tolerance to take into account when comparing off-diagonal elements
    
    absoluteTolerance - the absolute tolerance to take into account when comparing off-diagonal elements, and when checking if diagonal elements are equal to zero
    
    Returns:
    
    true if this is an antisymmetric matrix, false otherwise
  - walkInRowOrder
```
public double walkInRowOrder(RealMatrixChangingVisitor visitor)
```
    Visits (and possibly change) all matrix entries in row order.
    Row order starts at upper left element, iterating through all elements of a row from left to right before going to the leftmost element of the next row.
    
    Specified by:
    
    walkInRowOrder in interface RealMatrix
    
    Parameters:
    
    visitor - the visitor used to process all matrix entries
    
    Returns:
    
    the value returned by RealMatrixChangingVisitor.end() at the end of the walk
    
    See Also:
    
    RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor), RealMatrix.walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInRowOrder
```
public double walkInRowOrder(RealMatrixPreservingVisitor visitor)
```
    Visits (but don't change) all matrix entries in row order.
    Row order starts at upper left element, iterating through all elements of a row from left to right before going to the leftmost element of the next row.
    
    Specified by:
    
    walkInRowOrder in interface RealMatrix
    
    Parameters:
    
    visitor - the visitor used to process all matrix entries
    
    Returns:
    
    the value returned by RealMatrixPreservingVisitor.end() at the end of the walk
    
    See Also:
    
    RealMatrix.walkInRowOrder(RealMatrixChangingVisitor), RealMatrix.walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInRowOrder
```
public double walkInRowOrder(RealMatrixChangingVisitor visitor,
                             int startRow,
                             int endRow,
                             int startColumn,
                             int endColumn)
```
    Visits (and possibly change) some matrix entries in row order.
    Row order starts at upper left element, iterating through all elements of a row from left to right before going to the leftmost element of the next row.
    
    Specified by:
    
    walkInRowOrder in interface RealMatrix
    
    Parameters:
    
    visitor - the visitor used to process all matrix entries
    
    startRow - the initial row index
    
    endRow - the final row index (inclusive)
    
    startColumn - the initial column index
    
    endColumn - the final column index
    
    Returns:
    
    the value returned by RealMatrixChangingVisitor.end() at the end of the walk
    
    See Also:
    
    RealMatrix.walkInRowOrder(RealMatrixChangingVisitor), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInRowOrder
```
public double walkInRowOrder(RealMatrixPreservingVisitor visitor,
                             int startRow,
                             int endRow,
                             int startColumn,
                             int endColumn)
```
    Visits (but don't change) some matrix entries in row order.
    Row order starts at upper left element, iterating through all elements of a row from left to right before going to the leftmost element of the next row.
    
    Specified by:
    
    walkInRowOrder in interface RealMatrix
    
    Parameters:
    
    visitor - the visitor used to process all matrix entries
    
    startRow - the initial row index
    
    endRow - the final row index (inclusive)
    
    startColumn - the initial column index
    
    endColumn - the final column index
    
    Returns:
    
    the value returned by RealMatrixPreservingVisitor.end() at the end of the walk
    
    See Also:
    
    RealMatrix.walkInRowOrder(RealMatrixChangingVisitor), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor), RealMatrix.walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInColumnOrder
```
public double walkInColumnOrder(RealMatrixChangingVisitor visitor)
```
    Visits (and possibly change) all matrix entries in column order.
    Column order starts at upper left element, iterating through all elements of a column from top to bottom before going to the topmost element of the next column.
    
    Specified by:
    
    walkInColumnOrder in interface RealMatrix
    
    Parameters:
    
    visitor - the visitor used to process all matrix entries
    
    Returns:
    
    the value returned by RealMatrixChangingVisitor.end() at the end of the walk
    
    See Also:
    
    RealMatrix.walkInRowOrder(RealMatrixChangingVisitor), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor), RealMatrix.walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInColumnOrder
```
public double walkInColumnOrder(RealMatrixPreservingVisitor visitor)
```
    Visits (but don't change) all matrix entries in column order.
    Column order starts at upper left element, iterating through all elements of a column from top to bottom before going to the topmost element of the next column.
    
    Specified by:
    
    walkInColumnOrder in interface RealMatrix
    
    Parameters:
    
    visitor - the visitor used to process all matrix entries
    
    Returns:
    
    the value returned by RealMatrixPreservingVisitor.end() at the end of the walk
    
    See Also:
    
    RealMatrix.walkInRowOrder(RealMatrixChangingVisitor), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor), RealMatrix.walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInColumnOrder
```
public double walkInColumnOrder(RealMatrixChangingVisitor visitor,
                                int startRow,
                                int endRow,
                                int startColumn,
                                int endColumn)
```
    Visits (and possibly change) some matrix entries in column order.
    Column order starts at upper left element, iterating through all elements of a column from top to bottom before going to the topmost element of the next column.
    
    Specified by:
    
    walkInColumnOrder in interface RealMatrix
    
    Parameters:
    
    visitor - the visitor used to process all matrix entries
    
    startRow - the initial row index
    
    endRow - the final row index (inclusive)
    
    startColumn - the initial column index
    
    endColumn - the final column index
    
    Returns:
    
    the value returned by RealMatrixChangingVisitor.end() at the end of the walk
    
    See Also:
    
    RealMatrix.walkInRowOrder(RealMatrixChangingVisitor), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor), RealMatrix.walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInColumnOrder
```
public double walkInColumnOrder(RealMatrixPreservingVisitor visitor,
                                int startRow,
                                int endRow,
                                int startColumn,
                                int endColumn)
```
    Visits (but don't change) some matrix entries in column order.
    Column order starts at upper left element, iterating through all elements of a column from top to bottom before going to the topmost element of the next column.
    
    Specified by:
    
    walkInColumnOrder in interface RealMatrix
    
    Parameters:
    
    visitor - the visitor used to process all matrix entries
    
    startRow - the initial row index
    
    endRow - the final row index (inclusive)
    
    startColumn - the initial column index
    
    endColumn - the final column index
    
    Returns:
    
    the value returned by RealMatrixPreservingVisitor.end() at the end of the walk
    
    See Also:
    
    RealMatrix.walkInRowOrder(RealMatrixChangingVisitor), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor), RealMatrix.walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInOptimizedOrder
```
public double walkInOptimizedOrder(RealMatrixChangingVisitor visitor)
```
    Visits (and possibly change) all matrix entries using the fastest possible order.
    The fastest walking order depends on the exact matrix class. It may be different from traditional row or column orders.
    
    Specified by:
    
    walkInOptimizedOrder in interface RealMatrix
    
    Parameters:
    
    visitor - the visitor used to process all matrix entries
    
    Returns:
    
    the value returned by RealMatrixChangingVisitor.end() at the end of the walk
    
    See Also:
    
    RealMatrix.walkInRowOrder(RealMatrixChangingVisitor), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor), RealMatrix.walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInOptimizedOrder
```
public double walkInOptimizedOrder(RealMatrixPreservingVisitor visitor)
```
    Visits (but don't change) all matrix entries using the fastest possible order.
    The fastest walking order depends on the exact matrix class. It may be different from traditional row or column orders.
    
    Specified by:
    
    walkInOptimizedOrder in interface RealMatrix
    
    Parameters:
    
    visitor - the visitor used to process all matrix entries
    
    Returns:
    
    the value returned by RealMatrixPreservingVisitor.end() at the end of the walk
    
    See Also:
    
    RealMatrix.walkInRowOrder(RealMatrixChangingVisitor), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor), RealMatrix.walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInOptimizedOrder
```
public double walkInOptimizedOrder(RealMatrixChangingVisitor visitor,
                                   int startRow,
                                   int endRow,
                                   int startColumn,
                                   int endColumn)
```
    Visits (and possibly change) some matrix entries using the fastest possible order.
    The fastest walking order depends on the exact matrix class. It may be different from traditional row or column orders.
    
    Specified by:
    
    walkInOptimizedOrder in interface RealMatrix
    
    Parameters:
    
    visitor - the visitor used to process all matrix entries
    
    startRow - the initial row index
    
    endRow - the final row index (inclusive)
    
    startColumn - the initial column index
    
    endColumn - the final column index (inclusive)
    
    Returns:
    
    the value returned by RealMatrixChangingVisitor.end() at the end of the walk
    
    See Also:
    
    RealMatrix.walkInRowOrder(RealMatrixChangingVisitor), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor), RealMatrix.walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInOptimizedOrder
```
public double walkInOptimizedOrder(RealMatrixPreservingVisitor visitor,
                                   int startRow,
                                   int endRow,
                                   int startColumn,
                                   int endColumn)
```
    Visits (but don't change) some matrix entries using the fastest possible order.
    The fastest walking order depends on the exact matrix class. It may be different from traditional row or column orders.
    
    Specified by:
    
    walkInOptimizedOrder in interface RealMatrix
    
    Parameters:
    
    visitor - the visitor used to process all matrix entries
    
    startRow - the initial row index
    
    endRow - the final row index (inclusive)
    
    startColumn - the initial column index
    
    endColumn - the final column index (inclusive)
    
    Returns:
    
    the value returned by RealMatrixPreservingVisitor.end() at the end of the walk
    
    See Also:
    
    RealMatrix.walkInRowOrder(RealMatrixChangingVisitor), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor), RealMatrix.walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor), RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor), RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int)
  - toString
```
public String toString()
```
    Get a string representation for this matrix.
    Default format is MatrixUtils.VISUAL_FORMAT.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    a string representation for this matrix
  - toString
```
public String toString(RealMatrixFormat realMatrixFormat)
```
    Gets a string representation of this matrix using the specified format.
    Several predefined matrix formats are available in MatrixUtils.
    
    Specified by:
    
    toString in interface RealMatrix
    
    Parameters:
    
    realMatrixFormat - the matrix format to be used
    
    Returns:
    
    a string representation of this matrix
    
    See Also:
    
    MatrixUtils.JAVA_FORMAT, MatrixUtils.OCTAVE_FORMAT, MatrixUtils.VISUAL_FORMAT, MatrixUtils.SUMMARY_FORMAT
  - equals
```
public boolean equals(Object object)
```
    Returns true if the provided object is a RealMatrix instance with the same dimensions as this matrix, whose entries are strictly equal to the entries of this matrix (no absolute or relative tolerance is taken into account when comparing the entries).
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    object - the object to be tested for equality
    
    Returns:
    
    true if the provided object is equal to this matrix
  - equals
```
public boolean equals(RealMatrix m,
                      double relativeThreshold,
                      double absoluteThreshold)
```
    Is this matrix numerically equivalent to another matrix?
    This method indicates if this matrix is equal to another matrix.
    To do so, the method checks that the two matrices have the same row/column dimensions, and that all entries are numerically equal. Two elements are considered to have different values if their absolute and relative differences are both above the specified tolerances.
    
    Specified by:
    
    equals in interface RealMatrix
    
    Parameters:
    
    m - the matrix to be tested for equality
    
    relativeThreshold - the relative tolerance to take into account when comparing the entries of the matrices
    
    absoluteThreshold - the absolute tolerance to take into account when comparing the entries of the matrices
    
    Returns:
    
    true if the tested matrix is numerically equivalent to this matrix, false otherwise
  - hashCode
```
public int hashCode()
```
    Computes a hash code for the matrix.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    hash code for matrix
  - getRowDimension
```
public abstract int getRowDimension()
```
    Returns the dimension of the codomain of this operator.
    
    Specified by:
    
    getRowDimension in interface AnyMatrix
    
    Specified by:
    
    getRowDimension in class RealLinearOperator
    
    Returns:
    
    the number of rows of the underlying matrix
  - getColumnDimension
```
public abstract int getColumnDimension()
```
    Returns the dimension of the domain of this operator.
    
    Specified by:
    
    getColumnDimension in interface AnyMatrix
    
    Specified by:
    
    getColumnDimension in class RealLinearOperator
    
    Returns:
    
    the number of columns of the underlying matrix
  - getEntry
```
public abstract double getEntry(int row,
                                int column)
```
    Gets the entry at the specified row and column.
    Row and column indices start at 0.
    
    Specified by:
    
    getEntry in interface RealMatrix
    
    Parameters:
    
    row - the row index of entry to be fetched
    
    column - the column index of entry to be fetched
    
    Returns:
    
    the matrix entry at the specified row and column
  - setEntry
```
public abstract void setEntry(int row,
                              int column,
                              double value)
```
    Sets the entry at the specified row and column to a new value.
    Row and column indices start at 0.
    
    Specified by:
    
    setEntry in interface RealMatrix
    
    Parameters:
    
    row - the row index of entry to be set
    
    column - the column index of entry to be set
    
    value - the new value of the entry
  - createMatrix
```
public abstract RealMatrix createMatrix(int rowDimension,
                                        int columnDimension)
```
    Creates a new matrix of the same type as this matrix.
    The returned matrix is filled with zeros. Its size is determined by the specified row and column dimensions, which must both be strictly positive. Additional constraints on the dimensions may apply depending on the implementation (for example, symmetric matrices must be square, which implies that the row and column dimensions must be equal).
    
    Specified by:
    
    createMatrix in interface RealMatrix
    
    Parameters:
    
    rowDimension - the number of rows in the new matrix
    
    columnDimension - the number of columns in the new matrix
    
    Returns:
    
    a new matrix of the same type as this matrix
  - copy
```
public abstract RealMatrix copy()
```
    Returns a deep copy of this matrix.
    
    Specified by:
    
    copy in interface RealMatrix
    
    Returns:
    
    a deep copy of this matrix

Class AbstractRealMatrix

Constructor Summary

Method Summary

Methods inherited from class fr.cnes.sirius.patrius.math.linear.RealLinearOperator

Methods inherited from class java.lang.Object

Constructor Detail

AbstractRealMatrix

AbstractRealMatrix

AbstractRealMatrix

Method Detail

checkSquare

add

subtract

scalarAdd

scalarMultiply

multiply

multiply

multiply

multiply

preMultiply

operate

operate

preMultiply

preMultiply

power

getData

getData

getDiagonal

getNorm

getFrobeniusNorm

getTrace

getMax

getMin

getSubMatrix

getSubMatrix

copySubMatrix

copySubMatrix

copySubMatrix

copySubMatrix

checkDestinationArray

setSubMatrix

getRowMatrix

setRowMatrix

getColumnMatrix

setColumnMatrix

getRowVector

setRowVector

getColumnVector

setColumnVector

getRow

setRow

getColumn

setColumn

addToEntry

multiplyEntry

transpose

transpose

concatenateHorizontally

concatenateHorizontally

concatenateVertically

concatenateVertically

concatenateDiagonally

concatenateDiagonally

concatenateDiagonally

setDefaultDecomposition

getDefaultDecomposition

getInverse

getInverse

isSquare

isOrthogonal

isDiagonal

isInvertible

isSymmetric

isSymmetric

isSymmetric

isAntisymmetric

walkInRowOrder

walkInRowOrder

walkInRowOrder

walkInRowOrder