MatrixUtils (OpenIMAJ master project 1.3.10 API)

java.lang.Object
- org.openimaj.math.matrix.MatrixUtils

```
public class MatrixUtils
extends Object
```
Miscellaneous matrix operations.

Author:

Sina Samangooei (ss@ecs.soton.ac.uk), Jonathon Hare (jsh2@ecs.soton.ac.uk)

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Jama.Matrix`	`abs(Jama.Matrix mat)` Return a copy of the input matrix with all elements set to their absolute value.
`static Jama.Matrix`	`all(Jama.Matrix x)`
`static Jama.Matrix`	`and(Jama.Matrix... x)`
`static boolean`	`anyNaNorInf(Jama.Matrix matrix)` Are any values NaN or Inf?
`static Jama.Matrix`	`convert(no.uib.cipr.matrix.DenseMatrix mjt)` Convert a `DenseMatrix` to a `Matrix`.
`static Jama.Matrix`	`convert(no.uib.cipr.matrix.DenseMatrix mjt, int nrows, int ncols)` Convert a `DenseMatrix` to a `Matrix`.
`static Jama.Matrix`	`covariance(Jama.Matrix m)` Compute the covariance matrix of the given samples (assumed each sample is a row).
`static Jama.Matrix`	`diag(double[] s)` Create a diagonal matrix
`static Jama.Matrix`	`diag(Jama.Matrix cv)` Extract the diagonal component from the given matrix
`static double[]`	`diagVector(Jama.Matrix cv)` Extract the diagonal component from the given matrix
`static EigenValueVectorPair`	`eig2x2(Jama.Matrix m)` An eigen decomposition that uses a deterministic method if the matrix is 2x2.
`static boolean`	`equals(Jama.Matrix m1, Jama.Matrix m2, double eps)` Check if two matrices are equal
`static Jama.Matrix`	`exp(Jama.Matrix m)` Return a copy of the input matrix where every value is the exponential of the elements, e to the X.
`static Jama.Matrix`	`fill(Jama.Matrix m, double v)` Fill a matrix with a constant value.
`static Jama.Matrix`	`fromRowPacked(double[] vector, int ncols)` Construct a matrix from a row-packed (i.e.
`static Jama.Matrix`	`greaterThan(Jama.Matrix x, double val)`
`static Jama.Matrix`	`greaterThanSet(Jama.Matrix x, int val, int toset)` for every value in x greater than val set toset
`static Jama.Matrix`	`hstack(Jama.Matrix... x)` horizontally stack all the matrices provided.
`static Jama.Matrix`	`incrColumn(Jama.Matrix m, int col, double value)` Increment values in a single column by a constant
`static Jama.Matrix`	`incrRow(Jama.Matrix m, int row, double value)` Increment values in a single column by a constant
`static Jama.Matrix`	`invSqrtSym(Jama.Matrix matrix)` Compute the inverse square root, X, of the symmetric matrix A; A^-(1/2)
`static Jama.Matrix`	`lessThan(Jama.Matrix x, double val)`
`static Jama.Matrix`	`lessThanSet(Jama.Matrix x, int val, int toset)` for every value in x less than val set toset
`static Jama.Matrix`	`matrixFromFloat(float[][] data)` Construct a matrix from a 2D float array of data.
`static double`	`maxAbsDiag(Jama.Matrix matrix)` Get the maximum absolute value of the diagonal.
`static Jama.Matrix`	`min(Jama.Matrix A, Jama.Matrix B)` min(A,B) returns an array the same size as A and B with the smallest elements taken from A or B.
`static double`	`minAbsDiag(Jama.Matrix matrix)` Get the minimum absolute value of the diagonal.
`static Jama.Matrix`	`minus(Jama.Matrix m, double v)` Subtract a constant from all values
`static Jama.Matrix`	`minusCol(Jama.Matrix in, Jama.Matrix col)` Subtract the given col vector (held as a Matrix) from every col of the given matrix, returning the result in a new matrix.
`static Jama.Matrix`	`minusRow(Jama.Matrix in, double[] row)` Subtract the given row vector from every row of the given matrix, returning the result in a new matrix.
`static double[][]`	`mtjToDoubleArray(no.uib.cipr.matrix.DenseMatrix mat)` Convert an mtj matrix into a 2d double array
`static Jama.Matrix`	`ntuples(Jama.Matrix A, Jama.Matrix B)` Given two row vectors, construct the power set of rowvector combinations
`static Jama.Matrix`	`ones(int rowDimension, int columnDimension)`
`static Jama.Matrix`	`plus(Jama.Matrix m, double v)` Add a constant to all values
`static Jama.Matrix`	`plusEquals(Jama.Matrix result, Jama.Matrix add)` Add a matrix to another inline.
`static Jama.Matrix`	`plusEqualsRow(Jama.Matrix mat, Jama.Matrix rows, int[] rowIndex)` Add the rows to the mat at rowIndex.
`static Jama.Matrix`	`pow(Jama.Matrix mat, double exp)` Return a copy of the matrix with all the values raised to a power.
`static Jama.Matrix`	`pseudoInverse(Jama.Matrix matrix)` Computes the Moore-Penrose pseudoinverse.
`static Jama.Matrix`	`randGaussian(int rows, int cols)` Generate a matrix with Gaussian distributed randoms
`static Jama.Matrix`	`range(double... range)` range is: - a single number (a) (0:1:a) - two numbers (a,b) (a:1:b) - three numbers (a,b,c) (a:b:c)
`static Jama.Matrix`	`range(int... range)` range is: - a single number (a) (0:1:a) - two numbers (a,b) (a:1:b) - three numbers (a,b,c) (a:b:c)
`static Jama.Matrix`	`rangePow(double d, double... range)` d to the power of each value in range.
`static Jama.Matrix`	`reduceRank(Jama.Matrix m, int rank)` Reduce the rank a matrix by estimating a the best (in a least-squares sense) approximation using the thin SVD.
`static Jama.Matrix`	`repmat(Jama.Matrix x, int i, int j)` Given a matrix, repeat the matrix over i rows and j columns
`static Jama.Matrix`	`reshape(Jama.Matrix m, int newRows)` Get a reshaped copy of the input matrix
`static Jama.Matrix`	`reshape(Jama.Matrix m, int newRows, boolean columnMajor)` Get a reshaped copy of the input matrix
`static Jama.Matrix`	`reverseColumns(Jama.Matrix m)` Create a copy of a matrix with the columns in reverse order.
`static Jama.Matrix`	`reverseColumnsInplace(Jama.Matrix m)` Reverse the column order of the input matrix inplace.
`static Jama.Matrix`	`reverseRows(Jama.Matrix m)` Create a copy of a matrix with the rows in reverse order.
`static Jama.Matrix`	`reverseRowsInplace(Jama.Matrix m)` Reverse the row order of the input matrix inplace.
`static Jama.Matrix`	`round(Jama.Matrix times)` round (using `Math.round(double)` each value of the matrix
`static Jama.Matrix`	`setColumn(Jama.Matrix m, int c, double v)` Set the values of the elements in a single column to a constant value.
`static Jama.Matrix`	`setRow(Jama.Matrix m, int r, double v)` Set the values of the elements in a single column to a constant value.
`static Jama.Matrix`	`sign(Jama.Matrix m)` For each element of X, sign(X) returns 1 if the element is greater than zero, 0 if it equals zero and -1 if it is less than zero.
`static double[]`	`solveHomogeneousSystem(no.uib.cipr.matrix.DenseMatrix A)` Solves the system `Ax = 0`, returning the vector x as an array.
`static double[]`	`solveHomogeneousSystem(double[][] A)` Solves the system `Ax = 0`, returning the vector x as an array.
`static double[]`	`solveHomogeneousSystem(Jama.Matrix A)` Solves the system `Ax = 0`, returning the vector x as an array.
`static double`	`sparsity(SparseMatrix matrix)` Compute the sparsity (i.e.
`static Jama.Matrix`	`sqrt(Jama.Matrix matrix)` Compute the principle square root, X, of the matrix A such that A=X*X
`static double`	`sum(Jama.Matrix mat)` Compute the sum of all elements of the matrix.
`static Jama.Matrix`	`sumCols(Jama.Matrix m)` Compute the sum of values in all cols
`static double`	`sumColumn(Jama.Matrix m, int col)` Compute the sum of values in a single column
`static double`	`sumRow(Jama.Matrix m, int row)` Compute the sum of values in a single row
`static Jama.Matrix`	`sumRows(Jama.Matrix m)` Compute the sum of values in all rows
`static EigenValueVectorPair`	`symmetricEig2x2(Jama.Matrix m)` Compute the real Eigen decomposition of a symmetric 2x2 matrix.
`static Jama.Matrix`	`tanh(Jama.Matrix m)` Return a copy of the input matrix where every value is the hyperbolic tangent of the elements.
`static Jama.Matrix`	`times(Jama.Matrix m, double val)` Multiply a matrix by a constant inplace, returning the matrix.
`static String`	`toJavaString(Jama.Matrix mat)` Format a matrix as a single-line string suitable for using in java
`static String`	`toMatlabString(Jama.Matrix mat)` Format a matrix as a single-line string suitable for using in matlab or octave
`static String`	`toPythonString(Jama.Matrix mat)` Format a matrix as a single-line string suitable for using in python
`static String`	`toString(Jama.Matrix mat)` Generate a `String` representation of a matrix.
`static double`	`trace(Jama.Matrix mat)`
`static int[]`	`valsToIndex(double[] vals)`
`static void`	`zero(Jama.Matrix m)` Zero the matrix

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

- Method Detail
  - anyNaNorInf
```
public static boolean anyNaNorInf(Jama.Matrix matrix)
```
    Are any values NaN or Inf?
    
    Parameters:
    
    matrix - matrix to test
    
    Returns:
    
    true if any elements are NaN or Inf; false otherwise
  - maxAbsDiag
```
public static double maxAbsDiag(Jama.Matrix matrix)
```
    Get the maximum absolute value of the diagonal.
    
    Parameters:
    
    matrix - the matrix
    
    Returns:
    
    the maximum absolute value
  - minAbsDiag
```
public static double minAbsDiag(Jama.Matrix matrix)
```
    Get the minimum absolute value of the diagonal.
    
    Parameters:
    
    matrix - the matrix
    
    Returns:
    
    the minimum absolute value
  - sqrt
```
public static Jama.Matrix sqrt(Jama.Matrix matrix)
```
    Compute the principle square root, X, of the matrix A such that A=X*X
    
    Parameters:
    
    matrix - the matrix
    
    Returns:
    
    the sqrt of the matrix
  - pseudoInverse
```
public static Jama.Matrix pseudoInverse(Jama.Matrix matrix)
```
    Computes the Moore-Penrose pseudoinverse. This is just a convenience wrapper around PseudoInverse.pseudoInverse(Matrix).
    
    Parameters:
    
    matrix - the matrix to invert.
    
    Returns:
    
    the inverted matrix
    
    See Also:
    
    PseudoInverse.pseudoInverse(Matrix)
  - invSqrtSym
```
public static Jama.Matrix invSqrtSym(Jama.Matrix matrix)
```
    Compute the inverse square root, X, of the symmetric matrix A; A^-(1/2)
    
    Parameters:
    
    matrix - the symmetric matrix
    
    Returns:
    
    the inverse sqrt of the matrix
  - abs
```
public static Jama.Matrix abs(Jama.Matrix mat)
```
    Return a copy of the input matrix with all elements set to their absolute value.
    
    Parameters:
    
    mat - the matrix.
    
    Returns:
    
    the absolute matrix.
  - equals
```
public static boolean equals(Jama.Matrix m1,
                             Jama.Matrix m2,
                             double eps)
```
    Check if two matrices are equal
    
    Parameters:
    
    m1 - first matrix
    
    m2 - second matrix
    
    eps - epsilon for checking values
    
    Returns:
    
    true if matrices have same size and all elements are equal within eps; false otherwise
  - pow
```
public static Jama.Matrix pow(Jama.Matrix mat,
                              double exp)
```
    Return a copy of the matrix with all the values raised to a power.
    
    Parameters:
    
    mat - the matrix.
    
    exp - the power.
    
    Returns:
    
    a matrix.
  - toString
```
public static String toString(Jama.Matrix mat)
```
    Generate a String representation of a matrix.
    
    Parameters:
    
    mat - the matrix
    
    Returns:
    
    a string representation
  - sum
```
public static double sum(Jama.Matrix mat)
```
    Compute the sum of all elements of the matrix.
    
    Parameters:
    
    mat - the matrix.
    
    Returns:
    
    the sum.
  - zero
```
public static void zero(Jama.Matrix m)
```
    Zero the matrix
    
    Parameters:
    
    m - the matrix
  - symmetricEig2x2
```
public static EigenValueVectorPair symmetricEig2x2(Jama.Matrix m)
```
    Compute the real Eigen decomposition of a symmetric 2x2 matrix. Warning: Doesn't check the size or whether the input is symmetric.
    
    Parameters:
    
    m - the matrix
    
    Returns:
    
    the Eigen vectors and values.
  - eig2x2
```
public static EigenValueVectorPair eig2x2(Jama.Matrix m)
```
    An eigen decomposition that uses a deterministic method if the matrix is 2x2. This function returns values as in EigenvalueDecomposition i.e. the largest eigen value is held in the [m.rows - 1,m.cols-1] (i.e. [1,1]) location
    
    Parameters:
    
    m -
    
    Returns:
    
    the decomposition
  - matrixFromFloat
```
public static Jama.Matrix matrixFromFloat(float[][] data)
```
    Construct a matrix from a 2D float array of data.
    
    Parameters:
    
    data - the data.
    
    Returns:
    
    the matrix.
  - reduceRank
```
public static Jama.Matrix reduceRank(Jama.Matrix m,
                                     int rank)
```
    Reduce the rank a matrix by estimating a the best (in a least-squares sense) approximation using the thin SVD.
    
    Parameters:
    
    m - the matrix to reduce.
    
    rank - the desired rank.
    
    Returns:
    
    the rank-reduced matrix.
  - convert
```
public static Jama.Matrix convert(no.uib.cipr.matrix.DenseMatrix mjt)
```
    Convert a DenseMatrix to a Matrix.
    
    Parameters:
    
    mjt - DenseMatrix to convert
    
    Returns:
    
    converted matrix.
  - convert
```
public static Jama.Matrix convert(no.uib.cipr.matrix.DenseMatrix mjt,
                                  int nrows,
                                  int ncols)
```
    Convert a DenseMatrix to a Matrix.
    
    Parameters:
    
    mjt - DenseMatrix to convert
    
    nrows - number of rows to copy
    
    ncols - number of columns to copy
    
    Returns:
    
    converted matrix.
  - reverseColumns
```
public static Jama.Matrix reverseColumns(Jama.Matrix m)
```
    Create a copy of a matrix with the columns in reverse order.
    
    Parameters:
    
    m - the input matrix
    
    Returns:
    
    a copy with the column order reversed
  - reverseColumnsInplace
```
public static Jama.Matrix reverseColumnsInplace(Jama.Matrix m)
```
    Reverse the column order of the input matrix inplace.
    
    Parameters:
    
    m - the input matrix
    
    Returns:
    
    the input matrix
  - reverseRows
```
public static Jama.Matrix reverseRows(Jama.Matrix m)
```
    Create a copy of a matrix with the rows in reverse order.
    
    Parameters:
    
    m - the input matrix
    
    Returns:
    
    a copy with the row order reversed
  - reverseRowsInplace
```
public static Jama.Matrix reverseRowsInplace(Jama.Matrix m)
```
    Reverse the row order of the input matrix inplace.
    
    Parameters:
    
    m - the input matrix
    
    Returns:
    
    the input matrix
  - diag
```
public static Jama.Matrix diag(double[] s)
```
    Create a diagonal matrix
    
    Parameters:
    
    s - length diagonal numbers
    
    Returns:
    
    new Matrix(s.length,s.length) s.t. diagonal element i,i = s[i]
  - setColumn
```
public static Jama.Matrix setColumn(Jama.Matrix m,
                                    int c,
                                    double v)
```
    Set the values of the elements in a single column to a constant value.
    
    Parameters:
    
    m - the matrix
    
    c - the column
    
    v - the constant value
    
    Returns:
    
    the matrix
  - setRow
```
public static Jama.Matrix setRow(Jama.Matrix m,
                                 int r,
                                 double v)
```
    Set the values of the elements in a single column to a constant value.
    
    Parameters:
    
    m - the matrix
    
    r - the row
    
    v - the constant value
    
    Returns:
    
    the matrix
  - fill
```
public static Jama.Matrix fill(Jama.Matrix m,
                               double v)
```
    Fill a matrix with a constant value.
    
    Parameters:
    
    m - the matrix
    
    v - the constant value
    
    Returns:
    
    the matrix
  - minus
```
public static Jama.Matrix minus(Jama.Matrix m,
                                double v)
```
    Subtract a constant from all values
    
    Parameters:
    
    m - the matrix
    
    v - the constant value
    
    Returns:
    
    the matrix
  - plus
```
public static Jama.Matrix plus(Jama.Matrix m,
                               double v)
```
    Add a constant to all values
    
    Parameters:
    
    m - the matrix
    
    v - the constant value
    
    Returns:
    
    the matrix
  - reshape
```
public static Jama.Matrix reshape(Jama.Matrix m,
                                  int newRows)
```
    Get a reshaped copy of the input matrix
    
    Parameters:
    
    m - the matrix to reshape
    
    newRows - the new number of rows
    
    Returns:
    
    new matrix
  - reshape
```
public static Jama.Matrix reshape(Jama.Matrix m,
                                  int newRows,
                                  boolean columnMajor)
```
    Get a reshaped copy of the input matrix
    
    Parameters:
    
    m - the matrix to reshape
    
    newRows - the new number of rows
    
    columnMajor - if true, values are drawn and placed down columns first. if false values are drawn and placed across rows first
    
    Returns:
    
    new matrix
  - sumColumn
```
public static double sumColumn(Jama.Matrix m,
                               int col)
```
    Compute the sum of values in a single column
    
    Parameters:
    
    m - the matrix
    
    col - the column
    
    Returns:
    
    the sum of values in column col
  - sumRow
```
public static double sumRow(Jama.Matrix m,
                            int row)
```
    Compute the sum of values in a single row
    
    Parameters:
    
    m - the matrix
    
    row - the row
    
    Returns:
    
    the sum of values in row row
  - incrColumn
```
public static Jama.Matrix incrColumn(Jama.Matrix m,
                                     int col,
                                     double value)
```
    Increment values in a single column by a constant
    
    Parameters:
    
    m - the matrix
    
    col - the column
    
    value - the constant
    
    Returns:
    
    the matrix
  - incrRow
```
public static Jama.Matrix incrRow(Jama.Matrix m,
                                  int row,
                                  double value)
```
    Increment values in a single column by a constant
    
    Parameters:
    
    m - the matrix
    
    row - the row
    
    value - the constant
    
    Returns:
    
    the sum of values in row row
  - round
```
public static Jama.Matrix round(Jama.Matrix times)
```
    round (using Math.round(double) each value of the matrix
    
    Parameters:
    
    times -
    
    Returns:
    
    same matrix as handed in
  - min
```
public static Jama.Matrix min(Jama.Matrix A,
                              Jama.Matrix B)
```
    min(A,B) returns an array the same size as A and B with the smallest elements taken from A or B. The dimensions of A and B must match
    
    Parameters:
    
    A -
    
    B -
    
    Returns:
    
    new Matrix filled with min from A and B
  - rangePow
```
public static Jama.Matrix rangePow(double d,
                                   double... range)
```
    d to the power of each value in range. as with range(double...) range is: - a single number (a) (0:1:a) - two numbers (a,b) (a:1:b) - three numbers (a,b,c) (a:b:c) any other amount of range results in a RuntimeException
    
    Parameters:
    
    d -
    
    range -
    
    Returns:
    
    d to the power of each value in range
  - range
```
public static Jama.Matrix range(double... range)
```
    range is: - a single number (a) (0:1:a) - two numbers (a,b) (a:1:b) - three numbers (a,b,c) (a:b:c)
    
    Parameters:
    
    range -
    
    Returns:
    
    the range defined
  - range
```
public static Jama.Matrix range(int... range)
```
    range is: - a single number (a) (0:1:a) - two numbers (a,b) (a:1:b) - three numbers (a,b,c) (a:b:c)
    
    Parameters:
    
    range -
    
    Returns:
    
    the range defined
  - ntuples
```
public static Jama.Matrix ntuples(Jama.Matrix A,
                                  Jama.Matrix B)
```
    Given two row vectors, construct the power set of rowvector combinations
    
    Parameters:
    
    A -
    
    B -
    
    Returns:
    
    a new matrix of size A.cols * B.cols
  - repmat
```
public static Jama.Matrix repmat(Jama.Matrix x,
                                 int i,
                                 int j)
```
    Given a matrix, repeat the matrix over i rows and j columns
    
    Parameters:
    
    x -
    
    i -
    
    j -
    
    Returns:
    
    repeated matrix
  - hstack
```
public static Jama.Matrix hstack(Jama.Matrix... x)
```
    horizontally stack all the matrices provided. i.e. ret = [x1 x2 x3 x4 ... xn]
    
    Parameters:
    
    x -
    
    Returns:
    
    horizontally stacked
  - plusEqualsRow
```
public static Jama.Matrix plusEqualsRow(Jama.Matrix mat,
                                        Jama.Matrix rows,
                                        int[] rowIndex)
```
    Add the rows to the mat at rowIndex. Assumes MANY things with no checks: rows.rows == rowIndex.length mat.cols == rows.cols rowIndex.length < mat.rows for x in rowIndex: x < mat.rows && x >= 0 etc.
    
    Parameters:
    
    mat -
    
    rows -
    
    rowIndex -
    
    Returns:
    
    the input matrix
  - lessThan
```
public static Jama.Matrix lessThan(Jama.Matrix x,
                                   double val)
```
    Parameters:
    
    x -
    
    val -
    
    Returns:
    
    a new matrix for x < val
  - greaterThan
```
public static Jama.Matrix greaterThan(Jama.Matrix x,
                                      double val)
```
    Parameters:
    
    x -
    
    val -
    
    Returns:
    
    a new matrix for x > val
  - and
```
public static Jama.Matrix and(Jama.Matrix... x)
```
    Parameters:
    
    x -
    
    Returns:
    
    a new matrix for x1 && x2 && ... && xn where && means "!=0"
  - ones
```
public static Jama.Matrix ones(int rowDimension,
                               int columnDimension)
```
    Parameters:
    
    rowDimension -
    
    columnDimension -
    
    Returns:
    
    matrix of dimensions filled with ones
  - all
```
public static Jama.Matrix all(Jama.Matrix x)
```
    Parameters:
    
    x -
    
    Returns:
    
    logical-and each column of x
  - valsToIndex
```
public static int[] valsToIndex(double[] vals)
```
    Parameters:
    
    vals -
    
    Returns:
    
    given vals, return the array indexes where vals != 0
  - greaterThanSet
```
public static Jama.Matrix greaterThanSet(Jama.Matrix x,
                                         int val,
                                         int toset)
```
    for every value in x greater than val set toset
    
    Parameters:
    
    x -
    
    val -
    
    toset -
    
    Returns:
    
    same matrix handed in
  - lessThanSet
```
public static Jama.Matrix lessThanSet(Jama.Matrix x,
                                      int val,
                                      int toset)
```
    for every value in x less than val set toset
    
    Parameters:
    
    x -
    
    val -
    
    toset -
    
    Returns:
    
    same matrix handed in
  - minusRow
```
public static Jama.Matrix minusRow(Jama.Matrix in,
                                   double[] row)
```
    Subtract the given row vector from every row of the given matrix, returning the result in a new matrix.
    
    Parameters:
    
    in - the matrix
    
    row - the row vector
    
    Returns:
    
    the resultant matrix
  - minusCol
```
public static Jama.Matrix minusCol(Jama.Matrix in,
                                   Jama.Matrix col)
```
    Subtract the given col vector (held as a Matrix) from every col of the given matrix, returning the result in a new matrix.
    
    Parameters:
    
    in - the matrix
    
    col - the col Matrix (Only the first column is used)
    
    Returns:
    
    the resultant matrix
  - plusEquals
```
public static Jama.Matrix plusEquals(Jama.Matrix result,
                                     Jama.Matrix add)
```
    Add a matrix to another inline.
    
    Parameters:
    
    result - the matrix to add to
    
    add - the matrix to add
    
    Returns:
    
    the result matrix
  - times
```
public static Jama.Matrix times(Jama.Matrix m,
                                double val)
```
    Multiply a matrix by a constant inplace, returning the matrix.
    
    Parameters:
    
    m - the matrix
    
    val - the value to multiply by
    
    Returns:
    
    the matrix
  - mtjToDoubleArray
```
public static double[][] mtjToDoubleArray(no.uib.cipr.matrix.DenseMatrix mat)
```
    Convert an mtj matrix into a 2d double array
    
    Parameters:
    
    mat -
    
    Returns:
    
    a double array
  - sumRows
```
public static Jama.Matrix sumRows(Jama.Matrix m)
```
    Compute the sum of values in all rows
    
    Parameters:
    
    m - the matrix
    
    Returns:
    
    the sum of values across all cols in all rows
  - sumCols
```
public static Jama.Matrix sumCols(Jama.Matrix m)
```
    Compute the sum of values in all cols
    
    Parameters:
    
    m - the matrix
    
    Returns:
    
    the sum of values across all rows in all cols
  - randGaussian
```
public static Jama.Matrix randGaussian(int rows,
                                       int cols)
```
    Generate a matrix with Gaussian distributed randoms
    
    Parameters:
    
    rows - the number of rows
    
    cols - the number of columns
    
    Returns:
    
    a matrix containing values drawn from a 0 mean 1.0 sdev gaussian
  - sparsity
```
public static double sparsity(SparseMatrix matrix)
```
    Compute the sparsity (i.e. ratio of non-zero elements to matrix size) of the given matrix
    
    Parameters:
    
    matrix - the matrix
    
    Returns:
    
    the sparsity
  - diag
```
public static Jama.Matrix diag(Jama.Matrix cv)
```
    Extract the diagonal component from the given matrix
    
    Parameters:
    
    cv - the matrix
    
    Returns:
    
    a new matrix with the diagonal values from the input matrix and other values set to zero.
  - diagVector
```
public static double[] diagVector(Jama.Matrix cv)
```
    Extract the diagonal component from the given matrix
    
    Parameters:
    
    cv - the matrix
    
    Returns:
    
    a new matrix with the diagonal values from the input matrix and other values set to zero.
  - toMatlabString
```
public static String toMatlabString(Jama.Matrix mat)
```
    Format a matrix as a single-line string suitable for using in matlab or octave
    
    Parameters:
    
    mat - the matrix to format
    
    Returns:
    
    the string
  - toPythonString
```
public static String toPythonString(Jama.Matrix mat)
```
    Format a matrix as a single-line string suitable for using in python
    
    Parameters:
    
    mat - the matrix to format
    
    Returns:
    
    the string
  - trace
```
public static double trace(Jama.Matrix mat)
```
    Parameters:
    
    mat -
    
    Returns:
    
    trace of the matrix
  - solveHomogeneousSystem
```
public static double[] solveHomogeneousSystem(Jama.Matrix A)
```
    Solves the system Ax = 0, returning the vector x as an array. Internally computes the least-squares solution using the SVD of A.
    
    Parameters:
    
    A - the matrix describing the system
    
    Returns:
    
    the solution vector
  - solveHomogeneousSystem
```
public static double[] solveHomogeneousSystem(double[][] A)
```
    Solves the system Ax = 0, returning the vector x as an array. Internally computes the least-squares solution using the SVD of A.
    
    Parameters:
    
    A - the matrix describing the system
    
    Returns:
    
    the solution vector
  - solveHomogeneousSystem
```
public static double[] solveHomogeneousSystem(no.uib.cipr.matrix.DenseMatrix A)
```
    Solves the system Ax = 0, returning the vector x as an array. Internally computes the least-squares solution using the SVD of A.
    
    Parameters:
    
    A - the matrix describing the system
    
    Returns:
    
    the solution vector
  - toJavaString
```
public static String toJavaString(Jama.Matrix mat)
```
    Format a matrix as a single-line string suitable for using in java
    
    Parameters:
    
    mat - the matrix to format
    
    Returns:
    
    the string
  - fromRowPacked
```
public static Jama.Matrix fromRowPacked(double[] vector,
                                        int ncols)
```
    Construct a matrix from a row-packed (i.e. row-by-row) vector of the data.
    
    Parameters:
    
    vector - the row-packed vector
    
    ncols - the number of columns
    
    Returns:
    
    the reconstructed matrix
  - covariance
```
public static Jama.Matrix covariance(Jama.Matrix m)
```
    Compute the covariance matrix of the given samples (assumed each sample is a row).
    
    Parameters:
    
    m - the samples matrix
    
    Returns:
    
    the covariance matrix
  - sign
```
public static Jama.Matrix sign(Jama.Matrix m)
```
    For each element of X, sign(X) returns 1 if the element is greater than zero, 0 if it equals zero and -1 if it is less than zero.
    
    Parameters:
    
    m - the matrix
    
    Returns:
    
    the sign matrix
  - exp
```
public static Jama.Matrix exp(Jama.Matrix m)
```
    Return a copy of the input matrix where every value is the exponential of the elements, e to the X.
    
    Parameters:
    
    m - the input matrix
    
    Returns:
    
    the exponential matrix
  - tanh
```
public static Jama.Matrix tanh(Jama.Matrix m)
```
    Return a copy of the input matrix where every value is the hyperbolic tangent of the elements.
    
    Parameters:
    
    m - the input matrix
    
    Returns:
    
    the tanh matrix

Class MatrixUtils

Method Summary

Methods inherited from class java.lang.Object

Method Detail

anyNaNorInf

maxAbsDiag

minAbsDiag

sqrt

pseudoInverse

invSqrtSym

abs

equals

pow

toString

sum

zero

symmetricEig2x2

eig2x2

matrixFromFloat

reduceRank

convert

convert

reverseColumns

reverseColumnsInplace

reverseRows

reverseRowsInplace

diag

setColumn

setRow

fill

minus

plus

reshape

reshape

sumColumn

sumRow

incrColumn

incrRow

round

min

rangePow

range

range

ntuples

repmat

hstack

plusEqualsRow

lessThan

greaterThan

and

ones

all

valsToIndex

greaterThanSet

lessThanSet

minusRow

minusCol

plusEquals

times

mtjToDoubleArray

sumRows

sumCols

randGaussian

sparsity

diag

diagVector

toMatlabString

toPythonString

trace

solveHomogeneousSystem

solveHomogeneousSystem

solveHomogeneousSystem

toJavaString

fromRowPacked

covariance

sign

exp

tanh