RealMatrix (patrimoine de base SIRIUS 4.13 API)

All Superinterfaces:

AnyMatrix, Serializable

All Known Subinterfaces:

SymmetricMatrix, SymmetricPositiveMatrix

All Known Implementing Classes:

AbstractRealMatrix, Array2DRowRealMatrix, ArrayRowSymmetricMatrix, ArrayRowSymmetricPositiveMatrix, BlockRealMatrix, DecomposedSymmetricPositiveMatrix, DiagonalMatrix
```
public interface RealMatrix
extends AnyMatrix, Serializable
```
Interface defining a real-valued matrix with basic algebraic operations.
Matrix element indexing is 0-based -- e.g., getEntry(0, 0) returns the element in the first row, first column of the matrix.

Version:

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

Method Summary

All Methods Instance Methods Abstract Methods Default 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.
`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.
`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.
`RealMatrix`	`createMatrix(int rowDimension, int columnDimension)` Creates a new matrix of the same type as this matrix.
`boolean`	`equals(RealMatrix m, double relativeTolerance, double absoluteTolerance)` Is this matrix numerically equivalent to another matrix?
`RealMatrix`	`getAbs()` Returns the corresponding absolute values matrix.
`double[]`	`getColumn(int column)` Gets the entries of a given column.
`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.
`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.
`default double`	`getMax()` Returns the maximum value of the matrix.
`double`	`getMax(boolean absValue)` Returns the maximum value of the matrix.
`default double`	`getMin()` Returns the minimum value of the matrix.
`double`	`getMin(boolean absValue)` 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.
`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).
`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`	`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(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 postmultiplying this matrix by the vector `v`.
`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.
`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(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 interface fr.cnes.sirius.patrius.math.linear.AnyMatrix
getColumnDimension, getRowDimension, isSquare

- Method Detail
  - createMatrix
```
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).
    
    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
    
    Throws:
    
    NotStrictlyPositiveException - if row or column dimension is not positive.
    
    Since:
    
    2.0
  - copy
```
RealMatrix copy()
```
    Returns a deep copy of this matrix.
    
    Returns:
    
    a deep copy of this matrix
  - add
```
RealMatrix add(RealMatrix m)
```
    Returns the result of adding the matrix m to this matrix.
    
    Parameters:
    
    m - the matrix to be added
    
    Returns:
    
    the matrix resulting from the addition this+m
    
    Throws:
    
    MatrixDimensionMismatchException - if the matrix M is not the same size as this matrix
  - subtract
```
RealMatrix subtract(RealMatrix m)
```
    Returns the result of subtracting the matrix m from this matrix.
    
    Parameters:
    
    m - the matrix to be subtracted
    
    Returns:
    
    the matrix resulting from the subtraction this-m
    
    Throws:
    
    MatrixDimensionMismatchException - if the matrix m is not the same size as this matrix
  - scalarAdd
```
RealMatrix scalarAdd(double d)
```
    Returns the result of adding a scalar d to the entries of this matrix.
    
    Parameters:
    
    d - the scalar value to be added to the entries of this matrix
    
    Returns:
    
    the matrix resulting from the addition this+d
  - scalarMultiply
```
RealMatrix scalarMultiply(double d)
```
    Returns the result of multiplying the entries of this matrix by the scalar d.
    
    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
```
RealMatrix multiply(RealMatrix m)
```
    Returns the result of postmultiplying this matrix by the matrix m.
    
    Parameters:
    
    m - the matrix by which to postmultiply this matrix by
    
    Returns:
    
    the matrix resulting from the product this×m
    
    Throws:
    
    DimensionMismatchException - if the matrices are not multiplication compatible
  - multiply
```
RealMatrix multiply(RealMatrix m,
                    boolean toTranspose)
```
    Returns the result of postmultiplying this matrix by the matrix m or its transpose m^T.
    
    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
    
    Throws:
    
    DimensionMismatchException - if the matrices are not multiplication compatible
  - multiply
```
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.
    
    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
    
    Throws:
    
    DimensionMismatchException - if the matrices are not multiplication compatible
  - preMultiply
```
RealMatrix preMultiply(RealMatrix m)
```
    Returns the result of premultiplying this matrix by the matrix m.
    
    Parameters:
    
    m - the matrix M by which to premultiply this matrix by
    
    Returns:
    
    the matrix resulting from the product m×this
    
    Throws:
    
    DimensionMismatchException - if the matrices are not multiplication compatible
  - power
```
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.
    
    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
    
    Throws:
    
    NotPositiveException - if the exponent p is negative
    
    NonSquareMatrixException - if this matrix is not square
  - concatenateHorizontally
```
RealMatrix concatenateHorizontally(RealMatrix m)
```
    Horizontally concatenates this matrix and another matrix m, placing it in the right part of the concatenated matrix.
    
    Parameters:
    
    m - the matrix to be concatenated with this matrix
    
    Returns:
    
    the concatenated matrix
    
    Throws:
    
    DimensionMismatchException - if the matrices have different row dimensions
  - concatenateHorizontally
```
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]
 
```
    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
    
    Throws:
    
    DimensionMismatchException - if the matrices have different row dimensions
  - concatenateVertically
```
RealMatrix concatenateVertically(RealMatrix m)
```
    Vertically concatenates this matrix and another matrix m, placing it in the lower part of the concatenated matrix.
    
    Parameters:
    
    m - the matrix to be concatenated with this matrix
    
    Returns:
    
    the concatenated matrix
    
    Throws:
    
    DimensionMismatchException - if the matrices have different column dimensions
  - concatenateVertically
```
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]
 
```
    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
    
    Throws:
    
    DimensionMismatchException - if the matrices have different row dimensions
  - concatenateDiagonally
```
RealMatrix concatenateDiagonally(RealMatrix m)
```
    Diagonally concatenates this matrix and another matrix m, placing it in the lower right part of the concatenated matrix.
    
    Parameters:
    
    m - the matrix to be concatenated with this matrix
    
    Returns:
    
    the concatenated matrix
  - concatenateDiagonally
```
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]
 
```
    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
```
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]
 
```
    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
```
void setDefaultDecomposition(Function<RealMatrix,Decomposition> defaultDecompositionBuilder)
```
    Sets the decomposition builder the getInverse() method should use by default when computing the inverse of the matrix.
    
    Parameters:
    
    defaultDecompositionBuilder - the default decomposition builder
  - getDefaultDecomposition
```
Function<RealMatrix,Decomposition> getDefaultDecomposition()
```
    Gets the decomposition builder the getInverse() method uses by default when computing the inverse of the matrix.
    
    Returns:
    
    the default decomposition builder
  - getInverse
```
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.
    
    Returns:
    
    the inverse matrix
    
    Throws:
    
    SingularMatrixException - if the matrix is singular
    
    See Also:
    
    getDefaultDecomposition(), setDefaultDecomposition(Function)
  - getInverse
```
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).
    
    Parameters:
    
    decompositionBuilder - the decomposition builder to use
    
    Returns:
    
    the inverse matrix
    
    Throws:
    
    SingularMatrixException - if the matrix is singular
  - getData
```
double[][] getData()
```
    Returns a 2D array containing the entries of the matrix.
    
    Returns:
    
    a 2D array containing the entries of the matrix
  - getData
```
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.
    
    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
  - getTrace
```
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.
    
    Returns:
    
    the trace of the matrix
    
    Throws:
    
    NonSquareMatrixException - if the matrix is not square
  - getNorm
```
double getNorm()
```
    Returns the maximum absolute row sum norm of the matrix.
    
    Returns:
    
    the maximum absolute row sum norm of the matrix
  - getFrobeniusNorm
```
double getFrobeniusNorm()
```
    Returns the Frobenius norm of the matrix.
    
    Returns:
    
    the Frobenius norm of the matrix
  - getMin
```
default double getMin()
```
    Returns the minimum value of the matrix.
    
    Returns:
    
    the minimum value of the matrix
  - getMin
```
double getMin(boolean absValue)
```
    Returns the minimum value of the matrix.
    
    Parameters:
    
    absValue - Indicates if the absolute minimum value should be returned
    
    Returns:
    
    the minimum value of the matrix
  - getMax
```
default double getMax()
```
    Returns the maximum value of the matrix.
    
    Returns:
    
    the maximum value of the matrix
  - getMax
```
double getMax(boolean absValue)
```
    Returns the maximum value of the matrix.
    
    Parameters:
    
    absValue - Indicates if the absolute maximum value should be returned
    
    Returns:
    
    the maximum value of the matrix
  - getAbs
```
RealMatrix getAbs()
```
    Returns the corresponding absolute values matrix.
    
    Returns:
    
    the corresponding absolute values matrix
  - getSubMatrix
```
RealMatrix getSubMatrix(int startRow,
                        int endRow,
                        int startColumn,
                        int endColumn)
```
    Gets a submatrix.
    Rows and columns are indicated counting from 0 to n-1.
    
    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
    
    Throws:
    
    OutOfRangeException - if the row/column indices are not valid
    
    NumberIsTooSmallException - if endRow < startRow or endColumn < startColumn.
  - getSubMatrix
```
RealMatrix getSubMatrix(int[] selectedRows,
                        int[] selectedColumns)
```
    Gets a submatrix.
    Rows and columns are indicated counting from 0 to n-1.
    
    Parameters:
    
    selectedRows - the selected row indices
    
    selectedColumns - the selected column indices
    
    Returns:
    
    the submatrix containing the data in the specified rows and columns
    
    Throws:
    
    NullArgumentException - if the row or column selections are null
    
    NoDataException - if the row or column selections are empty (zero length)
    
    OutOfRangeException - if the selected indices are not valid
  - getDiagonal
```
double[] getDiagonal()
```
    Gets the diagonal vector from this matrix.
    Note: The matrix needs to be square.
    
    Returns:
    
    the diagonal vector from this matrix
    
    Throws:
    
    NonSquareMatrixException - if the matrix is not square
  - copySubMatrix
```
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).
    
    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
    
    Throws:
    
    OutOfRangeException - if the row/column indices are not valid
    
    NumberIsTooSmallException - if endRow < startRow or endColumn < startColumn
    
    MatrixDimensionMismatchException - if the destination array is too small
  - copySubMatrix
```
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).
    
    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
    
    Throws:
    
    OutOfRangeException - if the row/column indices are not valid
    
    NumberIsTooSmallException - if endRow < startRow or endColumn < startColumn.
    
    MatrixDimensionMismatchException - if the destination array is too small
  - copySubMatrix
```
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).
    
    Parameters:
    
    selectedRows - the selected row indices
    
    selectedColumns - the selected column indices
    
    destination - the 2D array where the submatrix data should be copied
    
    Throws:
    
    NullArgumentException - if the row or column selections are null
    
    NoDataException - if the row or column selections are empty (zero length)
    
    OutOfRangeException - if the selected indices are not valid
    
    MatrixDimensionMismatchException - if the destination array is too small
  - copySubMatrix
```
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).
    
    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
    
    Throws:
    
    NullArgumentException - if the row or column selections are null
    
    NoDataException - if the row or column selections are empty (zero length)
    
    OutOfRangeException - if the selected indices are not valid
    
    MatrixDimensionMismatchException - if the destination array is too small
  - setSubMatrix
```
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₁₁]
 
```
    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
    
    Throws:
    
    NullArgumentException - if the input submatrix array is null
    
    NoDataException - if the input submatrix array is empty
    
    DimensionMismatchException - if the rows of the input submatrix array have different lengths
    
    OutOfRangeException - if the input submatrix array does not fit into this matrix when starting from the specified top, left element
    
    Since:
    
    2.0
  - getRowMatrix
```
RealMatrix getRowMatrix(int row)
```
    Gets the entries of a given row as a row matrix.
    Row indices start at 0.
    
    Parameters:
    
    row - the index of the row to be fetched
    
    Returns:
    
    the extracted row matrix
    
    Throws:
    
    OutOfRangeException - if the specified row index is invalid
  - setRowMatrix
```
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.
    
    Parameters:
    
    row - the index of the row to be replaced
    
    matrix - the row matrix to be copied
    
    Throws:
    
    OutOfRangeException - if the specified row index is invalid
    
    MatrixDimensionMismatchException - if the row dimension of the provided matrix is not 1, or if its column dimension does not match the column dimension of this matrix
  - getColumnMatrix
```
RealMatrix getColumnMatrix(int column)
```
    Gets the entries of a given column as a column matrix.
    Column indices start at 0.
    
    Parameters:
    
    column - the index of the column to be fetched
    
    Returns:
    
    the extracted column matrix
    
    Throws:
    
    OutOfRangeException - if the specified column index is invalid
  - setColumnMatrix
```
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.
    
    Parameters:
    
    column - the index of the column to be replaced
    
    matrix - the column matrix to be copied
    
    Throws:
    
    OutOfRangeException - if the specified column index is invalid
    
    MatrixDimensionMismatchException - if the column dimension of the provided matrix is not 1, or if its row dimension does not match the row dimension of this matrix
  - getRowVector
```
RealVector getRowVector(int row)
```
    Gets the entries of a given row as a vector.
    Row indices start at 0.
    
    Parameters:
    
    row - the index of the row to be fetched
    
    Returns:
    
    the extracted row vector
    
    Throws:
    
    OutOfRangeException - if the specified row index is invalid
  - setRowVector
```
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.
    
    Parameters:
    
    row - the index of the row to be replaced
    
    vector - the row vector to be copied
    
    Throws:
    
    OutOfRangeException - if the specified row index is invalid
    
    MatrixDimensionMismatchException - if the dimension of the provided vector does not match the column dimension of this matrix
  - getColumnVector
```
RealVector getColumnVector(int column)
```
    Gets the entries of a given column as a vector.
    Column indices start at 0.
    
    Parameters:
    
    column - the index of the column to be fetched
    
    Returns:
    
    the extracted column vector
    
    Throws:
    
    OutOfRangeException - if the specified column index is invalid
  - setColumnVector
```
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.
    
    Parameters:
    
    column - the index of the column to be replaced
    
    vector - the column vector to be copied
    
    Throws:
    
    OutOfRangeException - if the specified column index is invalid
    
    MatrixDimensionMismatchException - if the dimension of the provided vector does not match the row dimension of this matrix
  - getRow
```
double[] getRow(int row)
```
    Gets the entries of a given row.
    Row indices start at 0.
    
    Parameters:
    
    row - the index of the row to be fetched
    
    Returns:
    
    the extracted row data
    
    Throws:
    
    OutOfRangeException - if the specified row index is invalid
  - setRow
```
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.
    
    Parameters:
    
    row - the index of the row to be replaced
    
    array - the row data array to be copied
    
    Throws:
    
    OutOfRangeException - if the specified row index is invalid
    
    MatrixDimensionMismatchException - if the length of the provided data array does not match the column dimension of this matrix
  - getColumn
```
double[] getColumn(int column)
```
    Gets the entries of a given column.
    Column indices start at 0.
    
    Parameters:
    
    column - the index of the column to be fetched
    
    Returns:
    
    the extracted column data
    
    Throws:
    
    OutOfRangeException - if the specified column index is invalid
  - setColumn
```
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.
    
    Parameters:
    
    column - the index of the column to be replaced
    
    array - the column data array to be copied
    
    Throws:
    
    OutOfRangeException - if the specified column index is invalid
    
    MatrixDimensionMismatchException - if the length of the provided data array does not match the row dimension of this matrix
  - getEntry
```
double getEntry(int row,
                int column)
```
    Gets the entry at the specified row and column.
    Row and column indices start at 0.
    
    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
    
    Throws:
    
    OutOfRangeException - if the row or column index is not valid
  - setEntry
```
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.
    
    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
    
    Throws:
    
    OutOfRangeException - if the row or column index is not valid
    
    Since:
    
    2.0
  - addToEntry
```
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.
    
    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
    
    Throws:
    
    OutOfRangeException - if the row or column index is not valid
    
    Since:
    
    2.0
  - multiplyEntry
```
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.
    
    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
    
    Throws:
    
    OutOfRangeException - if the row or column index is not valid
    
    Since:
    
    2.0
  - transpose
```
RealMatrix transpose()
```
    Returns the transpose of this matrix.
    
    Returns:
    
    the transpose of this matrix
  - transpose
```
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).
    
    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
  - isOrthogonal
```
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.
    
    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
```
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.
    
    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
```
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.
    
    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
```
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.
    
    Returns:
    
    true if this is a symmetric matrix, false otherwise
  - isSymmetric
```
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.
    
    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
```
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.
    
    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
```
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.
    
    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
  - operate
```
double[] operate(double[] v)
```
    Returns the result of postmultiplying this matrix by the vector v.
    
    Parameters:
    
    v - the vector by which to multiply this matrix by
    
    Returns:
    
    the column vector resulting from the product this×v
    
    Throws:
    
    DimensionMismatchException - if the length of provided array does not match the column dimension of this matrix
  - operate
```
RealVector operate(RealVector v)
```
    Returns the result of postmultiplying this matrix by the vector v.
    
    Parameters:
    
    v - the vector by which to multiply this matrix by
    
    Returns:
    
    the column vector resulting from the product this×v
    
    Throws:
    
    DimensionMismatchException - if the dimension of the provided vector does not match the column dimension of this matrix
  - preMultiply
```
double[] preMultiply(double[] v)
```
    Returns the result of premultiplying this matrix by the vector v.
    
    Parameters:
    
    v - the row vector by which to premultiply this matrix by
    
    Returns:
    
    the row vector resulting from the product v×this
    
    Throws:
    
    DimensionMismatchException - if the length of the provided array does not match the row dimension of this matrix
  - preMultiply
```
RealVector preMultiply(RealVector v)
```
    Returns the result of premultiplying this matrix by the vector v.
    
    Parameters:
    
    v - the vector by which to premultiply this matrix by
    
    Returns:
    
    the row vector resulting from the product v×this
    
    Throws:
    
    DimensionMismatchException - if the dimension of the provided vector does not match the row dimension of this matrix
  - walkInRowOrder
```
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.
    
    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:
    
    walkInRowOrder(RealMatrixPreservingVisitor), walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixChangingVisitor), walkInColumnOrder(RealMatrixPreservingVisitor), walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixChangingVisitor), walkInOptimizedOrder(RealMatrixPreservingVisitor), walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInRowOrder
```
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.
    
    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:
    
    walkInRowOrder(RealMatrixChangingVisitor), walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixChangingVisitor), walkInColumnOrder(RealMatrixPreservingVisitor), walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixChangingVisitor), walkInOptimizedOrder(RealMatrixPreservingVisitor), walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInRowOrder
```
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.
    
    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
    
    Throws:
    
    OutOfRangeException - if the specified indices are not valid
    
    NumberIsTooSmallException - if endRow < startRow or endColumn < startColumn
    
    See Also:
    
    walkInRowOrder(RealMatrixChangingVisitor), walkInRowOrder(RealMatrixPreservingVisitor), walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixChangingVisitor), walkInColumnOrder(RealMatrixPreservingVisitor), walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixChangingVisitor), walkInOptimizedOrder(RealMatrixPreservingVisitor), walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInRowOrder
```
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.
    
    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
    
    Throws:
    
    OutOfRangeException - if the specified indices are not valid
    
    NumberIsTooSmallException - if endRow < startRow or endColumn < startColumn
    
    See Also:
    
    walkInRowOrder(RealMatrixChangingVisitor), walkInRowOrder(RealMatrixPreservingVisitor), walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixChangingVisitor), walkInColumnOrder(RealMatrixPreservingVisitor), walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixChangingVisitor), walkInOptimizedOrder(RealMatrixPreservingVisitor), walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInColumnOrder
```
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.
    
    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:
    
    walkInRowOrder(RealMatrixChangingVisitor), walkInRowOrder(RealMatrixPreservingVisitor), walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixPreservingVisitor), walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixChangingVisitor), walkInOptimizedOrder(RealMatrixPreservingVisitor), walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInColumnOrder
```
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.
    
    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:
    
    walkInRowOrder(RealMatrixChangingVisitor), walkInRowOrder(RealMatrixPreservingVisitor), walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixChangingVisitor), walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixChangingVisitor), walkInOptimizedOrder(RealMatrixPreservingVisitor), walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInColumnOrder
```
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.
    
    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
    
    Throws:
    
    OutOfRangeException - if the specified indices are not valid
    
    NumberIsTooSmallException - if endRow < startRow or endColumn < startColumn
    
    See Also:
    
    walkInRowOrder(RealMatrixChangingVisitor), walkInRowOrder(RealMatrixPreservingVisitor), walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixChangingVisitor), walkInColumnOrder(RealMatrixPreservingVisitor), walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixChangingVisitor), walkInOptimizedOrder(RealMatrixPreservingVisitor), walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInColumnOrder
```
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.
    
    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
    
    Throws:
    
    OutOfRangeException - if the specified indices are not valid
    
    NumberIsTooSmallException - if endRow < startRow or endColumn < startColumn
    
    See Also:
    
    walkInRowOrder(RealMatrixChangingVisitor), walkInRowOrder(RealMatrixPreservingVisitor), walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixChangingVisitor), walkInColumnOrder(RealMatrixPreservingVisitor), walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixChangingVisitor), walkInOptimizedOrder(RealMatrixPreservingVisitor), walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInOptimizedOrder
```
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.
    
    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:
    
    walkInRowOrder(RealMatrixChangingVisitor), walkInRowOrder(RealMatrixPreservingVisitor), walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixChangingVisitor), walkInColumnOrder(RealMatrixPreservingVisitor), walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixPreservingVisitor), walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInOptimizedOrder
```
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.
    
    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:
    
    walkInRowOrder(RealMatrixChangingVisitor), walkInRowOrder(RealMatrixPreservingVisitor), walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixChangingVisitor), walkInColumnOrder(RealMatrixPreservingVisitor), walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixChangingVisitor), walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInOptimizedOrder
```
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.
    
    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
    
    Throws:
    
    OutOfRangeException - if the specified indices are not valid
    
    NumberIsTooSmallException - if endRow < startRow or endColumn < startColumn
    
    See Also:
    
    walkInRowOrder(RealMatrixChangingVisitor), walkInRowOrder(RealMatrixPreservingVisitor), walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixChangingVisitor), walkInColumnOrder(RealMatrixPreservingVisitor), walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixChangingVisitor), walkInOptimizedOrder(RealMatrixPreservingVisitor), walkInOptimizedOrder(RealMatrixPreservingVisitor, int, int, int, int)
  - walkInOptimizedOrder
```
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.
    
    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
    
    Throws:
    
    OutOfRangeException - if the specified indices are not valid
    
    NumberIsTooSmallException - if endRow < startRow or endColumn < startColumn
    
    See Also:
    
    walkInRowOrder(RealMatrixChangingVisitor), walkInRowOrder(RealMatrixPreservingVisitor), walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int), walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixChangingVisitor), walkInColumnOrder(RealMatrixPreservingVisitor), walkInColumnOrder(RealMatrixChangingVisitor, int, int, int, int), walkInColumnOrder(RealMatrixPreservingVisitor, int, int, int, int), walkInOptimizedOrder(RealMatrixChangingVisitor), walkInOptimizedOrder(RealMatrixPreservingVisitor), walkInOptimizedOrder(RealMatrixChangingVisitor, int, int, int, int)
  - toString
```
String toString(RealMatrixFormat realMatrixFormat)
```
    Gets a string representation of this matrix using the specified format.
    Several predefined matrix formats are available in MatrixUtils.
    
    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
```
boolean equals(RealMatrix m,
               double relativeTolerance,
               double absoluteTolerance)
```
    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.
    
    Parameters:
    
    m - the matrix to be tested for equality
    
    relativeTolerance - the relative tolerance to take into account when comparing the entries of the matrices
    
    absoluteTolerance - 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

Interface RealMatrix

Method Summary

Methods inherited from interface fr.cnes.sirius.patrius.math.linear.AnyMatrix

Method Detail

createMatrix

copy

add

subtract

scalarAdd

scalarMultiply

multiply

multiply

multiply

preMultiply

power

concatenateHorizontally

concatenateHorizontally

concatenateVertically

concatenateVertically

concatenateDiagonally

concatenateDiagonally

concatenateDiagonally

setDefaultDecomposition

getDefaultDecomposition

getInverse

getInverse

getData

getData

getTrace

getNorm

getFrobeniusNorm

getMin

getMin

getMax

getMax

getAbs

getSubMatrix

getSubMatrix

getDiagonal

copySubMatrix

copySubMatrix

copySubMatrix

copySubMatrix

setSubMatrix

getRowMatrix

setRowMatrix

getColumnMatrix

setColumnMatrix

getRowVector

setRowVector

getColumnVector

setColumnVector

getRow

setRow

getColumn

setColumn

getEntry

setEntry

addToEntry

multiplyEntry

transpose

transpose

isOrthogonal

isDiagonal

isInvertible

isSymmetric

isSymmetric

isSymmetric

isAntisymmetric

operate

operate

preMultiply

preMultiply

walkInRowOrder

walkInRowOrder

walkInRowOrder

walkInRowOrder

walkInColumnOrder

walkInColumnOrder

walkInColumnOrder