MatrixUtils (patrimoine de base SIRIUS 4.11 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 String`	`CARRIER_RETURN` Carrier return ('\n').
`static String`	`CLOSING_BRACKET` Closing bracket character (']').
`static String`	`CLOSING_CURLY_BRACKET` Closing curly bracket character ('}').
`static String`	`COMMA` Comma character (',').
`static RealMatrixFormat`	`DEFAULT_FORMAT` The default `RealMatrixFormat`.
`static RealMatrixFormat`	`JAVA_FORMAT` The JAVA format for `RealMatrix` objects.
`static String`	`NUMBER_FORMAT` Format number.
`static RealMatrixFormat`	`OCTAVE_FORMAT` A format for `RealMatrix` objects compatible with octave.
`static String`	`OPENING_BRACKET` Opening bracket character ('[').
`static String`	`OPENING_CURLY_BRACKET` Opening curly bracket character ('{').
`static RealMatrixFormat`	`SCILAB_FORMAT` The SCILAB format for `RealMatrix` objects.
`static String`	`SEMICOLON` Semicolon character (';') .
`static String`	`SPACE` Space character (' ').
`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`	`checkArrayIndex(double[][] array, int row, int column)` Checks if the provided indices are valid row and column indices for a given 2D-array.
`static void`	`checkColumnDimension(int columnDimension)` Checks the validity of the provided column dimension (must be strictly positive).
`static void`	`checkColumnIndex(AnyMatrix m, int column)` Checks if an index is a valid column index for a given matrix.
`static void`	`checkColumnIndices(AnyMatrix m, int[] indices)` Checks if the provided indices are valid column indices for a given matrix.
`static void`	`checkDimension(int expected, int actual)` Check if the provided dimension is the one expected.
`static void`	`checkDuplicates(int[] array)` Checks if the provided array contains duplicates.
`static void`	`checkMatrixArray(double[][] data)` Checks the validity of a matrix data array.
`static void`	`checkMatrixArray(double[][] data, boolean checkColumnDimensions)` Checks the validity of a matrix data array.
`static void`	`checkMatrixArray(Object[][] data)` Checks the validity of a matrix data array.
`static void`	`checkMatrixArray(Object[][] data, boolean checkColumnDimensions)` Checks the validity of a matrix data array.
`static void`	`checkMatrixIndex(AnyMatrix m, int row, int column)` Checks if the provided indices are valid row and column indices are for a given matrix.
`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`	`checkRowDimension(int rowDimension)` Checks the validity of the provided row dimension (must be strictly positive).
`static void`	`checkRowIndex(AnyMatrix m, int row)` Checks if an index is a valid row index for a given matrix.
`static void`	`checkRowIndices(AnyMatrix m, int[] indices)` Checks if the provided indices are valid row indices for a given matrix.
`static void`	`checkSubMatrixIndex(AnyMatrix m, int[] selectedRows, int[] selectedColumns)` Checks if the provided submatrix indices are valid for a given matrix.
`static void`	`checkSubMatrixIndex(AnyMatrix m, int startRow, int endRow, int startColumn, int endColumn)` Checks if the provided submatrix ranges are valid for a given matrix.
`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)` Checks if the matrix is symmetric and throws an exception if that's not the case.
`static RealMatrix`	`concatenateHorizontally(RealMatrix left, RealMatrix right)` Concatenates two matrices horizontally.
`static RealMatrix`	`concatenateVertically(RealMatrix upper, RealMatrix lower)` Concatenates two matrices vertically.
`static double[][]`	`copyArray(double[][] array)` Returns a deep copy of a 2D `double` array.
`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 diagonalMatrixInstance)` 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 RealMatrix`	`deserializeRealMatrix(ObjectInputStream ois)` Deserialize a `RealMatrix` field in a class.
`static RealVector`	`deserializeRealVector(ObjectInputStream ois)` Deserialize a `RealVector` field in a class.
`static Array2DRowRealMatrix`	`fractionMatrixToRealMatrix(FieldMatrix<Fraction> m)` Convert a `FieldMatrix`/`Fraction` matrix to a `RealMatrix`.
`static int[]`	`getColumnPermutationIndexArray(AnyMatrix m, int[] preSelectedColumns)` Builds a column permutation index array for a given matrix, starting with the preselected columns.
`static int[]`	`getRowPermutationIndexArray(AnyMatrix m, int[] preSelectedRows)` Builds a row permutation index array for a given matrix, starting with the preselected rows.
`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
  - NUMBER_FORMAT
```
public static final String NUMBER_FORMAT
```
    Format number.
    
    See Also:
    
    Constant Field Values
  - OPENING_CURLY_BRACKET
```
public static final String OPENING_CURLY_BRACKET
```
    Opening curly bracket character ('{').
    
    See Also:
    
    Constant Field Values
  - CLOSING_CURLY_BRACKET
```
public static final String CLOSING_CURLY_BRACKET
```
    Closing curly bracket character ('}').
    
    See Also:
    
    Constant Field Values
  - OPENING_BRACKET
```
public static final String OPENING_BRACKET
```
    Opening bracket character ('[').
    
    See Also:
    
    Constant Field Values
  - CLOSING_BRACKET
```
public static final String CLOSING_BRACKET
```
    Closing bracket character (']').
    
    See Also:
    
    Constant Field Values
  - SPACE
```
public static final String SPACE
```
    Space character (' ').
    
    See Also:
    
    Constant Field Values
  - COMMA
```
public static final String COMMA
```
    Comma character (',').
    
    See Also:
    
    Constant Field Values
  - SEMICOLON
```
public static final String SEMICOLON
```
    Semicolon character (';') .
    
    See Also:
    
    Constant Field Values
  - CARRIER_RETURN
```
public static final String CARRIER_RETURN
```
    Carrier return ('\n').
    
    See Also:
    
    Constant Field Values
  - DEFAULT_FORMAT
```
public static final RealMatrixFormat DEFAULT_FORMAT
```
    The default RealMatrixFormat.
    
    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 - the number of rows of the matrix
    
    columns - the number of columns of the matrix
    
    Returns:
    
    a new 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 - the field to which the matrix elements belong
    
    rows - number of rows of the matrix
    
    columns - number of columns of the matrix
    
    Returns:
    
    a new 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 - the input array
    
    Returns:
    
    a new RealMatrix containing the values of the input array
    
    Throws:
    
    NullArgumentException - if either data or data[0] is null
    
    NoDataException - if a row or column is empty
    
    DimensionMismatchException - if data is not rectangular (not all rows have the same length)
    
    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 either copied or referenced, depending on the forceCopyArray argument.
    
    Parameters:
    
    data - the input array
    
    forceCopyArray - if true, the input array is copied, otherwise it is referenced
    
    Returns:
    
    a new RealMatrix containing the values of the input array
    
    Throws:
    
    NullArgumentException - if either data or data[0] is null.
    
    NoDataException - if a row or column is empty.
    
    DimensionMismatchException - if data is not rectangular (not all rows have the same length)
    
    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 - the input array
    
    Returns:
    
    a matrix containing the values of the array.
    
    Throws:
    
    NullArgumentException - if either data or data[0] is null
    
    NoDataException - if a row or column is empty.
    
    DimensionMismatchException - if data is not rectangular (not all rows have the same length)
    
    Since:
    
    2.0
    
    See Also:
    
    createFieldMatrix(Field, int, int)
  - createRealIdentityMatrix
```
public static RealMatrix createRealIdentityMatrix(int dimension)
```
    Returns dimension x dimension identity matrix.
    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.
    
    Parameters:
    
    dimension - the dimension of identity matrix to be generated
    
    Returns:
    
    the generated identity matrix
    
    Throws:
    
    NotStrictlyPositiveException - if the specified dimension is not strictly positive
    
    Since:
    
    1.1
    
    See Also:
    
    createRealMatrix(int, int)
  - createRealIdentityMatrix
```
public static RealMatrix createRealIdentityMatrix(int dimension,
                                                  boolean diagonalMatrixInstance)
```
    Returns dimension x dimension identity matrix.
    If diagonalMatrixInstance is set to true, the generated identity matrix is a DiagonalMatrix instance. Otherwise, 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.
    
    Although DiagonalMatrix instances are optimized for storing diagonal matrices, they do have some limitations. Setting off-diagonal elements to non-zero values is forbidden, which means any attempt to modify the matrix will most likely result in an exception.
    
    Parameters:
    
    dimension - the dimension of identity matrix to be generated
    
    diagonalMatrixInstance - if true, the generated identity matrix is a DiagonalMatrix instance, otherwise it is either an Array2DRowRealMatrix or a BlockRealMatrix instance
    
    Returns:
    
    the generated identity matrix
    
    Throws:
    
    NotStrictlyPositiveException - if the specified dimension is not strictly positive
    
    Since:
    
    4.5
    
    See Also:
    
    createRealMatrix(int, int)
  - 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
  - copyArray
```
public static double[][] copyArray(double[][] array)
```
    Returns a deep copy of a 2D double array.
    
    Parameters:
    
    array - the array to be copied
    
    Returns:
    
    a deep copy of the provided array, or null if the supplied array is null
  - checkMatrixArray
```
public static void checkMatrixArray(double[][] data)
```
    Checks the validity of a matrix data array.
    To be valid, the provided data array must not be null or empty, its first row must also not be null or empty, and the rows must all have the same length.
    
    Parameters:
    
    data - the matrix data array to be checked
    
    Throws:
    
    NullArgumentException - if the data array is null
    
    NoDataException - if the data array is empty
    
    DimensionMismatchException - if the rows of the data array do not have a constant number of columns
  - checkMatrixArray
```
public static void checkMatrixArray(double[][] data,
                                    boolean checkColumnDimensions)
```
    Checks the validity of a matrix data array.
    To be valid, the provided data array must not be null or empty, and its first row must also not be null or empty. Setting checkColumnDimensions to true , enables an additional check which verifies that the rows all have the same length.
    
    Parameters:
    
    data - the matrix data array to be checked
    
    checkColumnDimensions - whether or not to check if the rows all have the same dimension
    
    Throws:
    
    NullArgumentException - if the data array is null
    
    NoDataException - if the data array is empty
    
    DimensionMismatchException - if the rows of the data array do not have a constant number of columns (optional check)
  - checkMatrixArray
```
public static void checkMatrixArray(Object[][] data)
```
    Checks the validity of a matrix data array.
    To be valid, the provided data array must not be null or empty, its first row must also not be null or empty, and the rows must all have the same length.
    
    Parameters:
    
    data - the matrix data array to be checked
    
    Throws:
    
    NullArgumentException - if the data array is null
    
    NoDataException - if the data array is empty
    
    DimensionMismatchException - if the rows of the data array do not have a constant number of columns
  - checkMatrixArray
```
public static void checkMatrixArray(Object[][] data,
                                    boolean checkColumnDimensions)
```
    Checks the validity of a matrix data array.
    To be valid, the provided data array must not be null or empty, and its first row must also not be null or empty. Setting checkColumnDimensions to true , enables an additional check which verifies that the rows all have the same length.
    
    Parameters:
    
    data - the matrix data array to be checked
    
    checkColumnDimensions - whether or not to check if the rows all have the same dimension
    
    Throws:
    
    NullArgumentException - if the data array is null
    
    NoDataException - if the data array is empty
    
    DimensionMismatchException - if the rows of the data array do not have a constant number of columns (optional check)
  - checkRowDimension
```
public static void checkRowDimension(int rowDimension)
```
    Checks the validity of the provided row dimension (must be strictly positive).
    
    Parameters:
    
    rowDimension - the row dimension to be checked
    
    Throws:
    
    NotStrictlyPositiveException - if the row dimension is not strictly positive
  - checkColumnDimension
```
public static void checkColumnDimension(int columnDimension)
```
    Checks the validity of the provided column dimension (must be strictly positive).
    
    Parameters:
    
    columnDimension - the column dimension to be checked
    
    Throws:
    
    NotStrictlyPositiveException - if the column dimension is not strictly positive
  - 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
  - checkArrayIndex
```
public static void checkArrayIndex(double[][] array,
                                   int row,
                                   int column)
```
    Checks if the provided indices are valid row and column indices for a given 2D-array.
    
    Parameters:
    
    array - the array
    
    row - the row index to be checked
    
    column - the column index to be checked
    
    Throws:
    
    OutOfRangeException - if the provided indices are not valid row or column indices
  - checkMatrixIndex
```
public static void checkMatrixIndex(AnyMatrix m,
                                    int row,
                                    int column)
```
    Checks if the provided indices are valid row and column indices are for a given matrix.
    
    Parameters:
    
    m - the matrix
    
    row - the row index to be checked
    
    column - the column index to be checked
    
    Throws:
    
    OutOfRangeException - if the provided indices are not valid row or column indices
  - checkRowIndex
```
public static void checkRowIndex(AnyMatrix m,
                                 int row)
```
    Checks if an index is a valid row index for a given matrix.
    
    Parameters:
    
    m - the matrix
    
    row - the row index to be checked
    
    Throws:
    
    OutOfRangeException - if the provided index is not a valid row index
  - checkColumnIndex
```
public static void checkColumnIndex(AnyMatrix m,
                                    int column)
```
    Checks if an index is a valid column index for a given matrix.
    
    Parameters:
    
    m - the matrix
    
    column - the column index to be checked
    
    Throws:
    
    OutOfRangeException - if the provided index is not a valid column index
  - checkRowIndices
```
public static void checkRowIndices(AnyMatrix m,
                                   int[] indices)
```
    Checks if the provided indices are valid row indices for a given matrix.
    This method throws an exception if the provided array is not a valid row index array. An index array is considered to be valid if it is not null or empty, and if each of its indices are between 0 to n-1, with n the row dimension of the matrix.
    
    Parameters:
    
    m - the matrix
    
    indices - the array of row indices
    
    Throws:
    
    NullArgumentException - if the provided index array is null
    
    NoDataException - if the provided index array is empty (zero length)
    
    OutOfRangeException - if one of the provided indices is not a valid row index
  - checkColumnIndices
```
public static void checkColumnIndices(AnyMatrix m,
                                      int[] indices)
```
    Checks if the provided indices are valid column indices for a given matrix.
    This method throws an exception if the provided array is not a valid row index array. An index array is considered to be valid if it is not null or empty, and if each of its indices are between 0 to n-1, with n the column dimension of the matrix.
    
    Parameters:
    
    m - the matrix
    
    indices - the array of column indices
    
    Throws:
    
    NullArgumentException - if the provided index array is null
    
    NoDataException - if the provided index array is empty (zero length)
    
    OutOfRangeException - if one of the provided indices is not a valid column index
  - checkSubMatrixIndex
```
public static void checkSubMatrixIndex(AnyMatrix m,
                                       int startRow,
                                       int endRow,
                                       int startColumn,
                                       int endColumn)
```
    Checks if the provided submatrix ranges are valid for a given matrix.
    Rows and columns are indicated counting from 0 to n - 1.
    
    Parameters:
    
    m - the matrix
    
    startRow - the initial row index
    
    endRow - the final row index
    
    startColumn - the initial column index
    
    endColumn - the final column index
    
    Throws:
    
    OutOfRangeException - if one of the provided indices is not a valid row or column index
    
    NumberIsTooSmallException - if endRow < startRow or endColumn < startColumn.
  - checkSubMatrixIndex
```
public static void checkSubMatrixIndex(AnyMatrix m,
                                       int[] selectedRows,
                                       int[] selectedColumns)
```
    Checks if the provided submatrix indices are valid for a given matrix.
    Rows and columns are indicated counting from 0 to n-1.
    
    Parameters:
    
    m - the matrix
    
    selectedRows - the array of row indices
    
    selectedColumns - the array of column indices
    
    Throws:
    
    NullArgumentException - if any of the provided index arrays is null
    
    NoDataException - if any of the provided index arrays is empty (zero length)
    
    OutOfRangeException - if any of the provided indices is not a valid row or column index
  - checkDuplicates
```
public static void checkDuplicates(int[] array)
```
    Checks if the provided array contains duplicates.
    
    Parameters:
    
    array - the array to be checked
    
    Throws:
    
    MathIllegalArgumentException - if the provided array contains any duplicates
  - checkSymmetry
```
public static void checkSymmetry(RealMatrix matrix,
                                 double absTol,
                                 double relTol)
```
    Checks if the matrix is symmetric and throws an exception if that's not the case.
    
    Parameters:
    
    matrix - the matrix to be checked
    
    absTol - the absolute threshold above which two off-diagonal elements are considered to be different
    
    relTol - the relative threshold above which two off-diagonal elements are considered to be different
    
    Throws:
    
    NonSymmetricMatrixException - if the provided matrix is not symmetric
  - getRowPermutationIndexArray
```
public static int[] getRowPermutationIndexArray(AnyMatrix m,
                                                int[] preSelectedRows)
```
    Builds a row permutation index array for a given matrix, starting with the preselected rows.
    This methods creates a permutation index array by completing the supplied index array with the missing row indices (in increasing order). The preselected indices must be valid row indices for the supplied matrix. Any duplicate found in the supplied index array is simply ignored.
    
    Usage examples, for a 5x4 matrix:
```
 getRowPermutation(m, {2, 3}) => {2, 3, 0, 1, 4}
 getRowPermutation(m, {0, 4, 1, 0}) => {0, 4, 1, 2, 3}
 
```
    Parameters:
    
    m - the matrix
    
    preSelectedRows - the preselected row indices
    
    Returns:
    
    the row permutation index array built
  - getColumnPermutationIndexArray
```
public static int[] getColumnPermutationIndexArray(AnyMatrix m,
                                                   int[] preSelectedColumns)
```
    Builds a column permutation index array for a given matrix, starting with the preselected columns.
    This methods creates a permutation index array by completing the supplied index array with the missing column indices (in increasing order). The preselected indices must be valid column indices for the supplied matrix. Any duplicate found in the supplied index array is simply ignored.
    
    Usage examples, for a 4x5 matrix:
```
 getColumnPermutation(m, {2, 3}) => {2, 3, 0, 1, 4}
 getColumnPermutation(m, {0, 4, 1, 0}) => {0, 4, 1, 2, 3}
 
```
    Parameters:
    
    m - the matrix
    
    preSelectedColumns - the preselected column indices
    
    Returns:
    
    the column permutation index array built
  - 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(ObjectInputStream)
  - deserializeRealVector
```
public static RealVector deserializeRealVector(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:
    
    ois - stream from which the real vector should be read
    
    Returns:
    
    read real vector
    
    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(ObjectInputStream)
  - deserializeRealMatrix
```
public static RealMatrix deserializeRealMatrix(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:
    
    ois - stream from which the real matrix should be read
    
    Returns:
    
    read real matrix
    
    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 compatible
    
    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 compatible
    
    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

NUMBER_FORMAT

OPENING_CURLY_BRACKET

CLOSING_CURLY_BRACKET

OPENING_BRACKET

CLOSING_BRACKET

SPACE

COMMA

SEMICOLON

CARRIER_RETURN

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

copyArray

checkMatrixArray

checkMatrixArray

checkMatrixArray

checkMatrixArray

checkRowDimension

checkColumnDimension

checkSymmetric

checkArrayIndex

checkMatrixIndex

checkRowIndex

checkColumnIndex

checkRowIndices

checkColumnIndices

checkSubMatrixIndex

checkSubMatrixIndex

checkDuplicates

checkSymmetry

getRowPermutationIndexArray

getColumnPermutationIndexArray

checkDimension

checkAdditionCompatible

checkSubtractionCompatible

checkMultiplicationCompatible

checkMultiplicationCompatible

fractionMatrixToRealMatrix

bigFractionMatrixToRealMatrix

serializeRealVector

deserializeRealVector

serializeRealMatrix

deserializeRealMatrix

solveLowerTriangularSystem

solveUpperTriangularSystem

blockInverse