MatrixUtils (patrius 4.5.1 API)

java.lang.Object
- fr.cnes.sirius.patrius.math.linear.MatrixUtils

```
public final class MatrixUtils
extends Object
```
A collection of static methods that operate on or return matrices.
This class is up-to-date with commons-math 3.6.1.

Version:

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

Field Summary

Fields
Modifier and Type	Field and Description
`static RealMatrixFormat`	`DEFAULT_FORMAT` Deprecated. since 4.5 the denomination has changed to `JAVA_FORMAT`
`static RealMatrixFormat`	`JAVA_FORMAT` The JAVA format for `RealMatrix` objects.
`static RealMatrixFormat`	`OCTAVE_FORMAT` A format for `RealMatrix` objects compatible with octave.
`static RealMatrixFormat`	`SCILAB_FORMAT` The SCILAB format for `RealMatrix` objects.
`static RealMatrixFormat`	`SUMMARY_FORMAT` Summary visual format for `RealMatrix` objects displayed on several rows.
`static RealMatrixFormat`	`VISUAL_FORMAT` Visual format for `RealMatrix` objects displayed on several rows.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Array2DRowRealMatrix`	`bigFractionMatrixToRealMatrix(FieldMatrix<BigFraction> m)` Convert a `FieldMatrix`/`BigFraction` matrix to a `RealMatrix`.
`static RealMatrix`	`blockInverse(RealMatrix m, int splitIndex)` Computes the inverse of the given matrix by splitting it into 4 sub-matrices.
`static void`	`checkAdditionCompatible(AnyMatrix left, AnyMatrix right)` Check if matrices are addition compatible.
`static void`	`checkColumnIndex(AnyMatrix m, int column)` Check if a column index is valid.
`static void`	`checkDimension(int expected, int actual)` Check if the provided dimension is the one expected.
`static void`	`checkMatrixIndex(AnyMatrix m, int row, int column)` Check if matrix indices are valid.
`static void`	`checkMultiplicationCompatible(AnyMatrix left, AnyMatrix right)` Check if matrices are multiplication compatible
`static void`	`checkMultiplicationCompatible(AnyMatrix left, AnyMatrix right, boolean rightToTransposed)` Check if matrices are multiplication compatible
`static void`	`checkPermutationMatrixIndex(AnyMatrix m, int[] index)` Check if the index array is compatible with the matrix m for permutation.
`static void`	`checkRowIndex(AnyMatrix m, int row)` Check if a row index is valid.
`static void`	`checkSubMatrixIndex(AnyMatrix m, int[] selectedRows, int[] selectedColumns)` Check if submatrix ranges indices are valid.
`static void`	`checkSubMatrixIndex(AnyMatrix m, int startRow, int endRow, int startColumn, int endColumn)` Check if submatrix ranges indices are valid.
`static void`	`checkSubtractionCompatible(AnyMatrix left, AnyMatrix right)` Check if matrices are subtraction compatible
`static void`	`checkSymmetric(RealMatrix matrix, double eps)` Checks whether a matrix is symmetric.
`static void`	`checkSymmetry(RealMatrix matrix, double absTol, double relTol)` Check if the matrix is symmetric.
`static int[]`	`completePermutationIndexList(AnyMatrix m, int[] preFilledIndex)` To make it easier to use the method `SymmetricMatrix.permutation(int[])` this method automatically fill a pre-filled index list (`preFilledIndex`) to process the permutation on a specified matrix (`m` ) (external process).
`static RealMatrix`	`concatenateHorizontally(RealMatrix left, RealMatrix right)` Concatenates two matrices horizontally.
`static RealMatrix`	`concatenateVertically(RealMatrix upper, RealMatrix lower)` Concatenates two matrices vertically.
`static <T extends FieldElement<T>> FieldMatrix<T>`	`createColumnFieldMatrix(T[] columnData)` Creates a column `FieldMatrix` using the data from the input array.
`static RealMatrix`	`createColumnRealMatrix(double[] columnData)` Creates a column `RealMatrix` using the data from the input array.
`static <T extends FieldElement<T>> FieldMatrix<T>`	`createFieldDiagonalMatrix(T[] diagonal)` Returns a diagonal matrix with specified elements.
`static <T extends FieldElement<T>> FieldMatrix<T>`	`createFieldIdentityMatrix(Field<T> field, int dimension)` Returns `dimension x dimension` identity matrix.
`static <T extends FieldElement<T>> FieldMatrix<T>`	`createFieldMatrix(Field<T> field, int rows, int columns)` Returns a `FieldMatrix` with specified dimensions.
`static <T extends FieldElement<T>> FieldMatrix<T>`	`createFieldMatrix(T[][] data)` Returns a `FieldMatrix` whose entries are the the values in the the input array.
`static <T extends FieldElement<T>> FieldVector<T>`	`createFieldVector(T[] data)` Creates a `FieldVector` using the data from the input array.
`static RealMatrix`	`createRealDiagonalMatrix(double[] diagonal)` Returns a diagonal matrix with specified elements.
`static RealMatrix`	`createRealIdentityMatrix(int dimension)` Returns `dimension x dimension` identity matrix.
`static RealMatrix`	`createRealIdentityMatrix(int dimension, boolean returnDiagonalMatrix)` Returns `dimension x dimension` identity matrix.
`static RealMatrix`	`createRealMatrix(double[][] data)` Returns a `RealMatrix` whose entries are the the values in the the input array.
`static RealMatrix`	`createRealMatrix(double[][] data, boolean forceCopyArray)` Returns a `RealMatrix` whose entries are the the values in the the input array.
`static RealMatrix`	`createRealMatrix(int rows, int columns)` Returns a `RealMatrix` with specified dimensions.
`static RealVector`	`createRealVector(double[] data)` Creates a `RealVector` using the data from the input array.
`static <T extends FieldElement<T>> FieldMatrix<T>`	`createRowFieldMatrix(T[] rowData)` Create a row `FieldMatrix` using the data from the input array.
`static RealMatrix`	`createRowRealMatrix(double[] rowData)` Create a row `RealMatrix` using the data from the input array.
`static void`	`deserializeRealMatrix(Object instance, String fieldName, ObjectInputStream ois)` Deserialize a `RealMatrix` field in a class.
`static void`	`deserializeRealVector(Object instance, String fieldName, ObjectInputStream ois)` Deserialize a `RealVector` field in a class.
`static Array2DRowRealMatrix`	`fractionMatrixToRealMatrix(FieldMatrix<Fraction> m)` Convert a `FieldMatrix`/`Fraction` matrix to a `RealMatrix`.
`static RealMatrix`	`multiplyByTranspose(double alpha, RealMatrix matrixL, RealMatrix matrixR)` Multiplies the matrix L by R^T and by a scalar factor α.
`static RealMatrix`	`multiplyByTranspose(RealMatrix matrixL, RealMatrix matrixR)` Multiplies the matrix L by R^T.
`static RealMatrix`	`resize(RealMatrix matrix, int rowDim, int colDim)` Resizes the provided matrix to a NxM matrix.
`static void`	`serializeRealMatrix(RealMatrix matrix, ObjectOutputStream oos)` Serialize a `RealMatrix`.
`static void`	`serializeRealVector(RealVector vector, ObjectOutputStream oos)` Serialize a `RealVector`.
`static void`	`solveLowerTriangularSystem(RealMatrix rm, RealVector b)` Solve a system of composed of a Lower Triangular Matrix `RealMatrix`.
`static void`	`solveUpperTriangularSystem(RealMatrix rm, RealVector b)` Solver a system composed of an Upper Triangular Matrix `RealMatrix`.

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

- Field Detail
  - DEFAULT_FORMAT
```
@Deprecated
public static final RealMatrixFormat DEFAULT_FORMAT
```
    Deprecated. since 4.5 the denomination has changed to JAVA_FORMAT
    
    The default format for RealMatrix objects.
    
    Since:
    
    3.1
  - JAVA_FORMAT
```
public static final RealMatrixFormat JAVA_FORMAT
```
    The JAVA format for RealMatrix objects.
    
    Since:
    
    4.5
  - OCTAVE_FORMAT
```
public static final RealMatrixFormat OCTAVE_FORMAT
```
    A format for RealMatrix objects compatible with octave.
    
    Since:
    
    3.1
  - SCILAB_FORMAT
```
public static final RealMatrixFormat SCILAB_FORMAT
```
    The SCILAB format for RealMatrix objects.
    
    Since:
    
    4.5
  - VISUAL_FORMAT
```
public static final RealMatrixFormat VISUAL_FORMAT
```
    Visual format for RealMatrix objects displayed on several rows. The pattern "% 11.5g" by default set the significant digit accuracy at 5, the width equal to 11, the format is automatically set to digital or scientific and the space between % and 11 allows to display the sign for scientific values.
    
    Since:
    
    4.5
  - SUMMARY_FORMAT
```
public static final RealMatrixFormat SUMMARY_FORMAT
```
    Summary visual format for RealMatrix objects displayed on several rows. The pattern "% 11.5g" by default set the significant digit accuracy at 5, the width equal to 11, the format is automatically set to digital or scientific and the space between % and 11 allows to display the sign for scientific values. The summary mode, with an index set to 3, will display the 3x3 sub-matrix in each corner and the rows and columns total number.
    
    Since:
    
    4.5
- Method Detail
  - createRealMatrix
```
public static RealMatrix createRealMatrix(int rows,
                                          int columns)
```
    Returns a RealMatrix with specified dimensions.
    The type of matrix returned depends on the dimension. Below 2¹² elements (i.e. 4096 elements or 64×64 for a square matrix) which can be stored in a 32kB array, a Array2DRowRealMatrix instance is built. Above this threshold a BlockRealMatrix instance is built.
    
    The matrix elements are all set to 0.0.
    
    Parameters:
    
    rows - number of rows of the matrix
    
    columns - number of columns of the matrix
    
    Returns:
    
    RealMatrix with specified dimensions
    
    See Also:
    
    createRealMatrix(double[][])
  - createFieldMatrix
```
public static <T extends FieldElement<T>> FieldMatrix<T> createFieldMatrix(Field<T> field,
                                                                           int rows,
                                                                           int columns)
```
    Returns a FieldMatrix with specified dimensions.
    The type of matrix returned depends on the dimension. Below 2¹² elements (i.e. 4096 elements or 64×64 for a square matrix), a FieldMatrix instance is built. Above this threshold a BlockFieldMatrix instance is built.
    
    The matrix elements are all set to field.getZero().
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field to which the matrix elements belong
    
    rows - number of rows of the matrix
    
    columns - number of columns of the matrix
    
    Returns:
    
    FieldMatrix with specified dimensions
    
    Since:
    
    2.0
    
    See Also:
    
    createFieldMatrix(FieldElement[][])
  - createRealMatrix
```
public static RealMatrix createRealMatrix(double[][] data)
```
    Returns a RealMatrix whose entries are the the values in the the input array.
    The type of matrix returned depends on the dimension. Below 2¹² elements (i.e. 4096 elements or 64×64 for a square matrix) which can be stored in a 32kB array, a Array2DRowRealMatrix instance is built. Above this threshold a BlockRealMatrix instance is built.
    
    The input array is copied, not referenced.
    
    Parameters:
    
    data - input array
    
    Returns:
    
    RealMatrix containing the values of the array
    
    Throws:
    
    DimensionMismatchException - if data is not rectangular (not all rows have the same length).
    
    NoDataException - if a row or column is empty.
    
    NullArgumentException - if either data or data[0] is null.
    
    DimensionMismatchException - if data is not rectangular.
    
    See Also:
    
    createRealMatrix(int, int)
  - createRealMatrix
```
public static RealMatrix createRealMatrix(double[][] data,
                                          boolean forceCopyArray)
```
    Returns a RealMatrix whose entries are the the values in the the input array.
    The type of matrix returned depends on the dimension. Below 2¹² elements (i.e. 4096 elements or 64×64 for a square matrix) which can be stored in a 32kB array, a Array2DRowRealMatrix instance is built. Above this threshold a BlockRealMatrix instance is built.
    
    The input array is copied, not referenced.
    
    Parameters:
    
    data - input array
    
    forceCopyArray - if true the input array is copied, else it is referenced.
    
    Returns:
    
    RealMatrix containing the values of the array
    
    Throws:
    
    DimensionMismatchException - if data is not rectangular (not all rows have the same length).
    
    NoDataException - if a row or column is empty.
    
    NullArgumentException - if either data or data[0] is null.
    
    DimensionMismatchException - if data is not rectangular.
    
    See Also:
    
    createRealMatrix(int, int)
  - createFieldMatrix
```
public static <T extends FieldElement<T>> FieldMatrix<T> createFieldMatrix(T[][] data)
```
    Returns a FieldMatrix whose entries are the the values in the the input array.
    The type of matrix returned depends on the dimension. Below 2¹² elements (i.e. 4096 elements or 64×64 for a square matrix), a FieldMatrix instance is built. Above this threshold a BlockFieldMatrix instance is built.
    
    The input array is copied, not referenced.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    data - input array
    
    Returns:
    
    a matrix containing the values of the array.
    
    Throws:
    
    DimensionMismatchException - if data is not rectangular (not all rows have the same length).
    
    NoDataException - if a row or column is empty.
    
    NullArgumentException - if either data or data[0] is null.
    
    Since:
    
    2.0
    
    See Also:
    
    createFieldMatrix(Field, int, int)
  - createRealIdentityMatrix
```
public static RealMatrix createRealIdentityMatrix(int dimension)
```
    Returns dimension x dimension identity matrix.
    
    Parameters:
    
    dimension - dimension of identity matrix to generate
    
    Returns:
    
    identity matrix
    
    Throws:
    
    IllegalArgumentException - if dimension is not positive
    
    Since:
    
    1.1
  - createRealIdentityMatrix
```
public static RealMatrix createRealIdentityMatrix(int dimension,
                                                  boolean returnDiagonalMatrix)
```
    Returns dimension x dimension identity matrix.
    
    Parameters:
    
    dimension - dimension of identity matrix to generate
    
    returnDiagonalMatrix - boolean indicator, if true a diagonal matrix will be returned, else a complete identity matrix will be returned
    
    Returns:
    
    identity matrix
    
    Throws:
    
    IllegalArgumentException - if dimension is not positive
    
    Since:
    
    4.5
  - createFieldIdentityMatrix
```
public static <T extends FieldElement<T>> FieldMatrix<T> createFieldIdentityMatrix(Field<T> field,
                                                                                   int dimension)
```
    Returns dimension x dimension identity matrix.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field to which the elements belong
    
    dimension - dimension of identity matrix to generate
    
    Returns:
    
    identity matrix
    
    Throws:
    
    IllegalArgumentException - if dimension is not positive
    
    Since:
    
    2.0
  - createRealDiagonalMatrix
```
public static RealMatrix createRealDiagonalMatrix(double[] diagonal)
```
    Returns a diagonal matrix with specified elements.
    
    Parameters:
    
    diagonal - diagonal elements of the matrix (the array elements will be copied)
    
    Returns:
    
    diagonal matrix
    
    Since:
    
    2.0
  - createFieldDiagonalMatrix
```
public static <T extends FieldElement<T>> FieldMatrix<T> createFieldDiagonalMatrix(T[] diagonal)
```
    Returns a diagonal matrix with specified elements.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    diagonal - diagonal elements of the matrix (the array elements will be copied)
    
    Returns:
    
    diagonal matrix
    
    Since:
    
    2.0
  - createRealVector
```
public static RealVector createRealVector(double[] data)
```
    Creates a RealVector using the data from the input array.
    
    Parameters:
    
    data - the input data
    
    Returns:
    
    a data.length RealVector
    
    Throws:
    
    NoDataException - if data is empty.
    
    NullArgumentException - if data is null.
  - createFieldVector
```
public static <T extends FieldElement<T>> FieldVector<T> createFieldVector(T[] data)
```
    Creates a FieldVector using the data from the input array.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    data - the input data
    
    Returns:
    
    a data.length FieldVector
    
    Throws:
    
    NoDataException - if data is empty.
    
    NullArgumentException - if data is null.
    
    ZeroException - if data has 0 elements
  - createRowRealMatrix
```
public static RealMatrix createRowRealMatrix(double[] rowData)
```
    Create a row RealMatrix using the data from the input array.
    
    Parameters:
    
    rowData - the input row data
    
    Returns:
    
    a 1 x rowData.length RealMatrix
    
    Throws:
    
    NoDataException - if rowData is empty.
    
    NullArgumentException - if rowData is null.
  - createRowFieldMatrix
```
public static <T extends FieldElement<T>> FieldMatrix<T> createRowFieldMatrix(T[] rowData)
```
    Create a row FieldMatrix using the data from the input array.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    rowData - the input row data
    
    Returns:
    
    a 1 x rowData.length FieldMatrix
    
    Throws:
    
    NoDataException - if rowData is empty.
    
    NullArgumentException - if rowData is null.
  - createColumnRealMatrix
```
public static RealMatrix createColumnRealMatrix(double[] columnData)
```
    Creates a column RealMatrix using the data from the input array.
    
    Parameters:
    
    columnData - the input column data
    
    Returns:
    
    a columnData x 1 RealMatrix
    
    Throws:
    
    NoDataException - if columnData is empty.
    
    NullArgumentException - if columnData is null.
  - createColumnFieldMatrix
```
public static <T extends FieldElement<T>> FieldMatrix<T> createColumnFieldMatrix(T[] columnData)
```
    Creates a column FieldMatrix using the data from the input array.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    columnData - the input column data
    
    Returns:
    
    a columnData x 1 FieldMatrix
    
    Throws:
    
    NoDataException - if data is empty.
    
    NullArgumentException - if columnData is null.
  - concatenateHorizontally
```
public static RealMatrix concatenateHorizontally(RealMatrix left,
                                                 RealMatrix right)
```
    Concatenates two matrices horizontally.
    
    Parameters:
    
    left - the left matrix [NxM]
    
    right - the right matrix [NxL]
    
    Returns:
    
    the concatenated matrix [Nx(M+L)]
    
    Throws:
    
    DimensionMismatchException - if the two matrices don't have the same number of rows
  - concatenateVertically
```
public static RealMatrix concatenateVertically(RealMatrix upper,
                                               RealMatrix lower)
```
    Concatenates two matrices vertically.
    
    Parameters:
    
    upper - the upper matrix [MxN]
    
    lower - the upper matrix [LxN]
    
    Returns:
    
    the concatenated matrix [(M+L)xN]
    
    Throws:
    
    DimensionMismatchException - if the two matrices don't have the same number of columns
  - resize
```
public static RealMatrix resize(RealMatrix matrix,
                                int rowDim,
                                int colDim)
```
    Resizes the provided matrix to a NxM matrix.
    The provided matrix is truncated or extended, depending on whether its dimensions are bigger or smaller than the requested dimensions. If extended, the terms added are set to zero.
    
    Parameters:
    
    matrix - the matrix to be truncated
    
    rowDim - the row dimension N of the matrix returned
    
    colDim - the column dimension M of the matrix returned
    
    Returns:
    
    the resized matrix (NxM)
  - multiplyByTranspose
```
public static RealMatrix multiplyByTranspose(RealMatrix matrixL,
                                             RealMatrix matrixR)
```
    Multiplies the matrix L by R^T.
    This methods allows to combine matrix multiplication and matrix transposition for optimization purposes.
    
    Parameters:
    
    matrixL - the left-side matrix L
    
    matrixR - the right-side matrix R (not its transpose)
    
    Returns:
    
    the result of the multiplication
  - multiplyByTranspose
```
public static RealMatrix multiplyByTranspose(double alpha,
                                             RealMatrix matrixL,
                                             RealMatrix matrixR)
```
    Multiplies the matrix L by R^T and by a scalar factor α.
    This methods allows to combine scalar multiplication, matrix multiplication and matrix transposition for optimization purposes.
    
    Parameters:
    
    alpha - the scalar factor α
    
    matrixL - the left-side matrix L
    
    matrixR - the right-side matrix R (not its transpose)
    
    Returns:
    
    the result of the multiplication
  - checkSymmetric
```
public static void checkSymmetric(RealMatrix matrix,
                                  double eps)
```
    Checks whether a matrix is symmetric.
    
    Parameters:
    
    matrix - Matrix to check.
    
    eps - Relative tolerance.
    
    Throws:
    
    NonSquareMatrixException - if the matrix is not square.
    
    NonSymmetricMatrixException - if the matrix is not symmetric.
    
    Since:
    
    3.1
  - checkMatrixIndex
```
public static void checkMatrixIndex(AnyMatrix m,
                                    int row,
                                    int column)
```
    Check if matrix indices are valid.
    
    Parameters:
    
    m - Matrix.
    
    row - Row index to check.
    
    column - Column index to check.
    
    Throws:
    
    OutOfRangeException - if row or column is not a valid index.
  - checkRowIndex
```
public static void checkRowIndex(AnyMatrix m,
                                 int row)
```
    Check if a row index is valid.
    
    Parameters:
    
    m - Matrix.
    
    row - Row index to check.
    
    Throws:
    
    OutOfRangeException - if row is not a valid index.
  - checkColumnIndex
```
public static void checkColumnIndex(AnyMatrix m,
                                    int column)
```
    Check if a column index is valid.
    
    Parameters:
    
    m - Matrix.
    
    column - Column index to check.
    
    Throws:
    
    OutOfRangeException - if column is not a valid index.
  - checkSubMatrixIndex
```
public static void checkSubMatrixIndex(AnyMatrix m,
                                       int startRow,
                                       int endRow,
                                       int startColumn,
                                       int endColumn)
```
    Check if submatrix ranges indices are valid. Rows and columns are indicated counting from 0 to n - 1.
    
    Parameters:
    
    m - Matrix.
    
    startRow - Initial row index.
    
    endRow - Final row index.
    
    startColumn - Initial column index.
    
    endColumn - Final column index.
    
    Throws:
    
    OutOfRangeException - if the indices are invalid.
    
    NumberIsTooSmallException - if endRow < startRow or endColumn < startColumn.
  - checkSubMatrixIndex
```
public static void checkSubMatrixIndex(AnyMatrix m,
                                       int[] selectedRows,
                                       int[] selectedColumns)
```
    Check if submatrix ranges indices are valid. Rows and columns are indicated counting from 0 to n-1.
    
    Parameters:
    
    m - Matrix.
    
    selectedRows - Array of row indices.
    
    selectedColumns - Array of column indices.
    
    Throws:
    
    NullArgumentException - if selectedRows or selectedColumns are null.
    
    NoDataException - if the row or column selections are empty (zero length).
    
    OutOfRangeException - if row or column selections are not valid.
  - checkSymmetry
```
public static void checkSymmetry(RealMatrix matrix,
                                 double absTol,
                                 double relTol)
```
    Check if the matrix is symmetric.
    
    Parameters:
    
    matrix - Matrix
    
    absTol - Absolute threshold
    
    relTol - Relative threshold
    
    Throws:
    
    PatriusException - if the matrix isn't symmetric
  - completePermutationIndexList
```
public static int[] completePermutationIndexList(AnyMatrix m,
                                                 int[] preFilledIndex)
```
    To make it easier to use the method SymmetricMatrix.permutation(int[]) this method automatically fill a pre-filled index list (preFilledIndex) to process the permutation on a specified matrix (m ) (external process).
    Requirements :
    - The matrix m needs to be square.
    - The pre-filled index list needs to have each of its index specified on the matrix dimension range and the array mustn't have any duplicated element.
    Usage example : We want to rearrange the rows/colums {2, 3} on a 5x5 matrix but we don't care about the others. Thanks to this method, the full-filled index list will be automatically build as {2, 3, 0, 1, 4}.
    
    Note : To fill the index list, the order is conservative when an index isn't specified.
    Parameters:
    
    m - The matrix to complete the index list on (only used for its dimensions)
    
    preFilledIndex - The pre-filled index list
    
    Returns:
    
    The full-filled index list
  - checkPermutationMatrixIndex
```
public static void checkPermutationMatrixIndex(AnyMatrix m,
                                               int[] index)
```
    Check if the index array is compatible with the matrix m for permutation. The matrix m must be square, the index array must have the same dimension as the matrix m, each index has to be unique and defined between 0 and n-1.
    
    Parameters:
    
    m - Matrix.
    
    index - index list.
    
    Throws:
    
    NonSquareMatrixException - if m isn't square.
    
    NullArgumentException - if index is null.
    
    DimensionMismatchException - if index isn't compatible with the matrix dimension
    
    NoDataException - if the row or column selections are empty (zero length).
    
    OutOfRangeException - if row (& column as square matrix) selections are not valid.
  - checkDimension
```
public static void checkDimension(int expected,
                                  int actual)
```
    Check if the provided dimension is the one expected.
    
    Parameters:
    
    expected - the expected dimension
    
    actual - the actual dimension
    
    Throws:
    
    DimensionMismatchException - if the provided dimension is not the one expected
  - checkAdditionCompatible
```
public static void checkAdditionCompatible(AnyMatrix left,
                                           AnyMatrix right)
```
    Check if matrices are addition compatible.
    
    Parameters:
    
    left - Left hand side matrix.
    
    right - Right hand side matrix.
    
    Throws:
    
    MatrixDimensionMismatchException - if the matrices are not addition compatible.
  - checkSubtractionCompatible
```
public static void checkSubtractionCompatible(AnyMatrix left,
                                              AnyMatrix right)
```
    Check if matrices are subtraction compatible
    
    Parameters:
    
    left - Left hand side matrix.
    
    right - Right hand side matrix.
    
    Throws:
    
    MatrixDimensionMismatchException - if the matrices are not subtraction compatible.
  - checkMultiplicationCompatible
```
public static void checkMultiplicationCompatible(AnyMatrix left,
                                                 AnyMatrix right)
```
    Check if matrices are multiplication compatible
    
    Parameters:
    
    left - Left hand side matrix.
    
    right - Right hand side matrix.
    
    Throws:
    
    DimensionMismatchException - if getColumnDimension(left) != getRowDimension(right)
  - checkMultiplicationCompatible
```
public static void checkMultiplicationCompatible(AnyMatrix left,
                                                 AnyMatrix right,
                                                 boolean rightToTransposed)
```
    Check if matrices are multiplication compatible
    
    Parameters:
    
    left - Left hand side matrix.
    
    right - Right hand side matrix.
    
    rightToTransposed - indicate if the right matrix will be transposed before the operation
    
    Throws:
    
    DimensionMismatchException - if getColumnDimension(left) != getRowDimension(right)
  - fractionMatrixToRealMatrix
```
public static Array2DRowRealMatrix fractionMatrixToRealMatrix(FieldMatrix<Fraction> m)
```
    Convert a FieldMatrix/Fraction matrix to a RealMatrix.
    
    Parameters:
    
    m - Matrix to convert.
    
    Returns:
    
    the converted matrix.
  - bigFractionMatrixToRealMatrix
```
public static Array2DRowRealMatrix bigFractionMatrixToRealMatrix(FieldMatrix<BigFraction> m)
```
    Convert a FieldMatrix/BigFraction matrix to a RealMatrix.
    
    Parameters:
    
    m - Matrix to convert.
    
    Returns:
    
    the converted matrix.
  - serializeRealVector
```
public static void serializeRealVector(RealVector vector,
                                       ObjectOutputStream oos)
                                throws IOException
```
    Serialize a RealVector.
    This method is intended to be called from within a private writeObject method (after a call to oos.defaultWriteObject()) in a class that has a RealVector field, which should be declared transient. This way, the default handling does not serialize the vector (the RealVector interface is not serializable by default) but this method does serialize it specifically.
    
    The following example shows how a simple class with a name and a real vector should be written:
```
 
 public class NamedVector implements Serializable {
 
     private final String name;
     private final transient RealVector coefficients;
 
     // omitted constructors, getters ...
 
     private void writeObject(ObjectOutputStream oos) throws IOException {
         oos.defaultWriteObject();  // takes care of name field
         MatrixUtils.serializeRealVector(coefficients, oos);
     }
 
     private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException {
         ois.defaultReadObject();  // takes care of name field
         MatrixUtils.deserializeRealVector(this, "coefficients", ois);
     }
 
 }
 
 
```
    Parameters:
    
    vector - real vector to serialize
    
    oos - stream where the real vector should be written
    
    Throws:
    
    IOException - if object cannot be written to stream
    
    See Also:
    
    deserializeRealVector(Object, String, ObjectInputStream)
  - deserializeRealVector
```
public static void deserializeRealVector(Object instance,
                                         String fieldName,
                                         ObjectInputStream ois)
                                  throws IOException
```
    Deserialize a RealVector field in a class.
    This method is intended to be called from within a private readObject method (after a call to ois.defaultReadObject()) in a class that has a RealVector field, which should be declared transient. This way, the default handling does not deserialize the vector (the RealVector interface is not serializable by default) but this method does deserialize it specifically.
    
    Parameters:
    
    instance - instance in which the field must be set up
    
    fieldName - name of the field within the class (may be private and final)
    
    ois - stream from which the real vector should be read
    
    Throws:
    
    IOException - if object cannot be read from the stream
    
    See Also:
    
    serializeRealVector(RealVector, ObjectOutputStream)
  - serializeRealMatrix
```
public static void serializeRealMatrix(RealMatrix matrix,
                                       ObjectOutputStream oos)
                                throws IOException
```
    Serialize a RealMatrix.
    This method is intended to be called from within a private writeObject method (after a call to oos.defaultWriteObject()) in a class that has a RealMatrix field, which should be declared transient. This way, the default handling does not serialize the matrix (the RealMatrix interface is not serializable by default) but this method does serialize it specifically.
    
    The following example shows how a simple class with a name and a real matrix should be written:
```
 
 public class NamedMatrix implements Serializable {
 
     private final String name;
     private final transient RealMatrix coefficients;
 
     // omitted constructors, getters ...
 
     private void writeObject(ObjectOutputStream oos) throws IOException {
         oos.defaultWriteObject();  // takes care of name field
         MatrixUtils.serializeRealMatrix(coefficients, oos);
     }
 
     private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException {
         ois.defaultReadObject();  // takes care of name field
         MatrixUtils.deserializeRealMatrix(this, "coefficients", ois);
     }
 
 }
 
 
```
    Parameters:
    
    matrix - real matrix to serialize
    
    oos - stream where the real matrix should be written
    
    Throws:
    
    IOException - if object cannot be written to stream
    
    See Also:
    
    deserializeRealMatrix(Object, String, ObjectInputStream)
  - deserializeRealMatrix
```
public static void deserializeRealMatrix(Object instance,
                                         String fieldName,
                                         ObjectInputStream ois)
                                  throws IOException
```
    Deserialize a RealMatrix field in a class.
    This method is intended to be called from within a private readObject method (after a call to ois.defaultReadObject()) in a class that has a RealMatrix field, which should be declared transient. This way, the default handling does not deserialize the matrix (the RealMatrix interface is not serializable by default) but this method does deserialize it specifically.
    
    Parameters:
    
    instance - instance in which the field must be set up
    
    fieldName - name of the field within the class (may be private and final)
    
    ois - stream from which the real matrix should be read
    
    Throws:
    
    IOException - if object cannot be read from the stream
    
    See Also:
    
    serializeRealMatrix(RealMatrix, ObjectOutputStream)
  - solveLowerTriangularSystem
```
public static void solveLowerTriangularSystem(RealMatrix rm,
                                              RealVector b)
```
    Solve a system of composed of a Lower Triangular Matrix RealMatrix.
    This method is called to solve systems of equations which are of the lower triangular form. The matrix RealMatrix is assumed, though not checked, to be in lower triangular form. The vector RealVector is overwritten with the solution. The matrix is checked that it is square and its dimensions match the length of the vector.
    
    Parameters:
    
    rm - RealMatrix which is lower triangular
    
    b - RealVector this is overwritten
    
    Throws:
    
    DimensionMismatchException - if the matrix and vector are not conformable
    
    NonSquareMatrixException - if the matrix rm is not square
    
    MathArithmeticException - if the absolute value of one of the diagonal coefficient of rm is lower than Precision.SAFE_MIN
  - solveUpperTriangularSystem
```
public static void solveUpperTriangularSystem(RealMatrix rm,
                                              RealVector b)
```
    Solver a system composed of an Upper Triangular Matrix RealMatrix.
    This method is called to solve systems of equations which are of the lower triangular form. The matrix RealMatrix is assumed, though not checked, to be in upper triangular form. The vector RealVector is overwritten with the solution. The matrix is checked that it is square and its dimensions match the length of the vector.
    
    Parameters:
    
    rm - RealMatrix which is upper triangular
    
    b - RealVector this is overwritten
    
    Throws:
    
    DimensionMismatchException - if the matrix and vector are not conformable
    
    NonSquareMatrixException - if the matrix rm is not square
    
    MathArithmeticException - if the absolute value of one of the diagonal coefficient of rm is lower than Precision.SAFE_MIN
  - blockInverse
```
public static RealMatrix blockInverse(RealMatrix m,
                                      int splitIndex)
```
    Computes the inverse of the given matrix by splitting it into 4 sub-matrices.
    
    Parameters:
    
    m - Matrix whose inverse must be computed.
    
    splitIndex - Index that determines the "split" line and column. The element corresponding to this index will part of the upper-left sub-matrix.
    
    Returns:
    
    the inverse of m.
    
    Throws:
    
    NonSquareMatrixException - if m is not square.

Class MatrixUtils

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_FORMAT

JAVA_FORMAT

OCTAVE_FORMAT

SCILAB_FORMAT

VISUAL_FORMAT

SUMMARY_FORMAT

Method Detail

createRealMatrix

createFieldMatrix

createRealMatrix

createRealMatrix

createFieldMatrix

createRealIdentityMatrix

createRealIdentityMatrix

createFieldIdentityMatrix

createRealDiagonalMatrix

createFieldDiagonalMatrix

createRealVector

createFieldVector

createRowRealMatrix

createRowFieldMatrix

createColumnRealMatrix

createColumnFieldMatrix

concatenateHorizontally

concatenateVertically

resize

multiplyByTranspose

multiplyByTranspose

checkSymmetric

checkMatrixIndex

checkRowIndex

checkColumnIndex

checkSubMatrixIndex

checkSubMatrixIndex

checkSymmetry

completePermutationIndexList

checkPermutationMatrixIndex

checkDimension

checkAdditionCompatible

checkSubtractionCompatible

checkMultiplicationCompatible

checkMultiplicationCompatible

fractionMatrixToRealMatrix

bigFractionMatrixToRealMatrix

serializeRealVector

deserializeRealVector

serializeRealMatrix

deserializeRealMatrix

solveLowerTriangularSystem

solveUpperTriangularSystem

blockInverse