DenseMatrix (Cognitive Foundry)

java.lang.Object
- gov.sandia.cognition.util.AbstractCloneableSerializable
- - gov.sandia.cognition.math.AbstractRing<Matrix>
  - - gov.sandia.cognition.math.matrix.AbstractMatrix
    - - gov.sandia.cognition.math.matrix.custom.DenseMatrix

All Implemented Interfaces:

Matrix, Vectorizable, Ring<Matrix>, CloneableSerializable, java.io.Serializable, java.lang.Cloneable, java.lang.Iterable<MatrixEntry>
```
public class DenseMatrix
extends AbstractMatrix
```
A dense matrix implementation. Wherever possible, computation is pushed into BLAS or LAPACK expecting that those will be considerably faster than code written by me.

Since:

3.4.3

Author:

Jeremy D. Wendt

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`DenseMatrix.LU` Simple container class for LU decompositions.
`static class`	`DenseMatrix.QR` Container class that stores the Q and R matrices formed by the QR decomposition of this.
`static class`	`DenseMatrix.SVD` Simple container class for Singular Value Decomposition (SVD) results.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`DenseMatrix()` This should never be called by anything or anyone other than Java's serialization code.
	`DenseMatrix(DenseMatrix m)` Copy constructor that creates a deep copy of the input matrix.
	`DenseMatrix(double[][] values)` Constructor for creating a dense matrix from a 2-d double array.
	`DenseMatrix(int numRows, int numCols)` Creates a zero matrix of the specified dimensions
	`DenseMatrix(int numRows, int numCols, double defaultVal)` Creates a matrix of default val in all cells of the specified dimensions
	`DenseMatrix(java.util.List<java.util.List<java.lang.Double>> values)` Constructor for creating a dense matrix from a 2-d double List.
	`DenseMatrix(Matrix m)` Copy constructor that copies any input Matrix -- creating a deep copy of the matrix.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`checkSolveDimensions(Matrix b)` Checks that the input matrix has the same numRows as this's numRows (otherwise, there can be no soluation for Ax = b).
`protected void`	`checkSolveDimensions(Vector b)` Checks that the input vector has the same dimensionality as this's numRows (otherwise, there can be no solution for Ax = b).
`protected void`	`checkSubmatrixRange(int minRow, int maxRow, int minCol, int maxCol)` Helper method checks that the input submatrix range is acceptable for this matrix, including that the max is greater than or equal to the min.
`Matrix`	`clone()` Returns a deep copy of this.
`void`	`convertFromVector(Vector v)` uploads a matrix from a column-stacked vector of parameters, so that v(k) = A(i,j) = A( k%M, k/M )
`Vector`	`convertToVector()` Creates a column-stacked version of this, so that v(k) = A(i,j) = v(j*M+i)
`Matrix`	`dotTimes(Matrix other)` Element-wise multiplication of `this` and `other`
`void`	`dotTimesEquals(DenseMatrix other)` Type-specific version of dotTimesEquals for combining whatever type this is with the input dense matrix.
`void`	`dotTimesEquals(DiagonalMatrix other)` Type-specific version of dotTimesEquals for combining whatever type this is with the input diagonal matrix.
`void`	`dotTimesEquals(Matrix other)` Inline element-wise multiplication of `this` and `other`
`void`	`dotTimesEquals(SparseMatrix other)` Type-specific version of dotTimesEquals for combining whatever type this is with the input sparse matrix.
`double`	`get(int rowIndex, int columnIndex)` Gets the value of the element of the matrix at the zero-based row and column indices.
`Vector`	`getColumn(int columnIndex)` Gets the specified column from the zero-based index and returns a vector that corresponds to that column.
`double`	`getElement(int rowIndex, int columnIndex)` Gets the Matrix element at the specified zero-based indices throws ArrayIndexOutOfBoundsException if either rowIndex or columnIndex are less than 0, or greater than the number of rows (columns) minus one (0 <= index <= num-1)
`int`	`getEntryCount()` Gets the number of active entries in the matrix.
`MatrixFactory<?>`	`getMatrixFactory()` Gets a matrix factory, typically one associated with this type of matrix.
`int`	`getNonZeroCount()` Simple method that computes the number of non-zero elements stored in this.
`double`	`getNonZeroPercent()` Returns the percentage of this that is non-zero elements
`int`	`getNumColumns()` Returns the number of columns in the Matrix
`int`	`getNumRows()` Returns the number of rows in the Matrix
`Vector`	`getRow(int rowIndex)` Gets the specified row from the zero-based index and returns a vector that corresponds to that column
`Matrix`	`getSubMatrix(int minRow, int maxRow, int minColumn, int maxColumn)` Gets the embedded submatrix inside of the Matrix, specified by the inclusive, zero-based indices such that the result matrix will have size (maxRow-minRow+1) x (maxColum-minCcolumn+1)
`void`	`identity()` Formats the matrix as an identity matrix.
`Matrix`	`inverse()` Computes the full-blown inverse of `this`, which must be a square matrix
`boolean`	`isSparse()` Returns true if this matrix has a potentially sparse underlying structure.
`boolean`	`isSymmetric(double effectiveZero)` Determines if the matrix is effectively symmetric
`java.util.Iterator<MatrixEntry>`	`iterator()`
`ComplexNumber`	`logDeterminant()` Computes the natural logarithm of the determinant of `this`.
`DenseMatrix.LU`	`luDecompose()` Leverages LAPACK to create the LU decomposition of this.
`Matrix`	`minus(Matrix other)` Arithmetic subtraction of `other` from `this`
`void`	`minusEquals(DenseMatrix other)` Type-specific version of minusEquals for combining whatever type this is with the input dense matrix.
`void`	`minusEquals(DiagonalMatrix other)` Type-specific version of minusEquals for combining whatever type this is with the input diagonal matrix.
`void`	`minusEquals(Matrix other)` Inline arithmetic subtraction of `other` from `this`
`void`	`minusEquals(SparseMatrix other)` Type-specific version of minusEquals for combining whatever type this is with the input sparse matrix.
`double`	`normFrobenius()` Compute the Frobenius norm of `this`, which is just a fancy way of saying that I will square each element, add those up, and square root the result.
`double`	`normFrobeniusSquared()` Compute the squared Frobenius norm of `this`, which is just a fancy way of saying that I will square each element and add those up.
`Matrix`	`plus(Matrix other)` Arithmetic addition of `this` and `other`
`void`	`plusEquals(DenseMatrix other)` Type-specific version of plusEquals for combining whatever type this is with the input dense matrix.
`void`	`plusEquals(DiagonalMatrix other)` Type-specific version of plusEquals for combining whatever type this is with the input diagonal matrix.
`void`	`plusEquals(Matrix other)` Inline arithmetic addition of `this` and `other`
`void`	`plusEquals(SparseMatrix other)` Type-specific version of plusEquals for combining whatever type this is with the input sparse matrix.
`Vector`	`preTimes(DenseVector vector)` Type-specific version of pre-times for combining whatever type this is with the input dense vector.
`Vector`	`preTimes(SparseVector vector)` Type-specific version of pre-times for combining whatever type this is with the input sparse vector.
`Vector`	`preTimes(Vector vector)` Package-private method that puts the vector * matrix code in the matrix class instead of in the vector class (why should vectors know the internals of matrices?).
`Matrix`	`pseudoInverse(double effectiveZero)` Computes the effective pseudo-inverse of `this`, using a rather expensive procedure (SVD)
`DenseMatrix.QR`	`qrDecompose()` Leverage LAPACK to compute the QR Decomposition of this.
`int`	`rank(double effectiveZero)` Computes the effective rank of `this`, which is the number of linearly independent rows and columns in `this`.
`void`	`scaledPlusEquals(DenseMatrix other, double scaleFactor)` Type-specific version of scaledPlusEquals for combining whatever type this is with the input dense matrix.
`void`	`scaledPlusEquals(DiagonalMatrix other, double scaleFactor)` Type-specific version of scaledPlusEquals for combining whatever type this is with the input diagonal matrix.
`void`	`scaledPlusEquals(double scaleFactor, Matrix other)` Inline arithmetic addition of `this` and `other` after element-wise scaling of `other` by `scaleFactor`.
`void`	`scaledPlusEquals(SparseMatrix other, double scaleFactor)` Type-specific version of scaledPlusEquals for combining whatever type this is with the input sparse matrix.
`void`	`scaleEquals(double scaleFactor)` Inline element-wise scaling of `this` by `scaleFactor`
`void`	`set(int rowIndex, int columnIndex, double value)` Sets the value of the element of the matrix at the zero-based row and column indices.
`void`	`setElement(int rowIndex, int columnIndex, double value)` Sets the Matrix element at the specified zero-based indices throws ArrayIndexOutOfBoundsException if either rowIndex or columnIndex are less than 0, or greater than the number of rows (columns) minus one (0 <= index <= num-1)
`Matrix`	`solve(Matrix B)` Solves for "X" in the equation: this*X = B
`Vector`	`solve(Vector b)` Solves for "x" in the equation: this*x = b
`DenseMatrix.SVD`	`svdDecompose()` Leverages LAPACK to compute the Singular Value Decomposition (SVD) of this.
`Matrix`	`times(DenseMatrix other)` Type-specific version of times for combining whatever type this is with the input dense matrix.
`Vector`	`times(DenseVector vector)` Type-specific version of times for combining whatever type this is with the input dense vector.
`Matrix`	`times(DiagonalMatrix other)` Type-specific version of times for combining whatever type this is with the input diagonal matrix.
`Matrix`	`times(Matrix other)` Matrix multiplication of `this` and `matrix`, operates like the "`*`" operator in Matlab
`Matrix`	`times(SparseMatrix other)` Type-specific version of times for combining whatever type this is with the input sparse matrix.
`Vector`	`times(SparseVector vector)` Type-specific version of times for combining whatever type this is with the input sparse vector.
`Vector`	`times(Vector vector)` Returns the column vector from the equation return = this * vector
`java.lang.String`	`toString(java.text.NumberFormat format)` Converts the vector to a `String`, using the given formatter.
`Matrix`	`transpose()` Returns the transpose of `this`

Methods inherited from class gov.sandia.cognition.math.matrix.AbstractMatrix
assertMultiplicationDimensions, assertSameDimensions, checkMultiplicationDimensions, checkSameDimensions, decrement, decrement, dotDivide, dotDivideEquals, equals, equals, getColumnInto, getRowInto, hashCode, increment, increment, isSquare, isSymmetric, isZero, pseudoInverse, rank, setColumn, setRow, setSubMatrix, sumOfColumns, sumOfRows, toArray, trace, valuesAsList

Methods inherited from class gov.sandia.cognition.math.AbstractRing
isZero, negative, negativeEquals, scale, scaledMinus, scaledMinusEquals, scaledPlus, zero

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

Methods inherited from interface gov.sandia.cognition.math.matrix.Matrix
toString

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface gov.sandia.cognition.math.Ring
isZero, negative, negativeEquals, scale, scaledMinus, scaledMinusEquals, scaledPlus, zero

- Constructor Detail
  - DenseMatrix
```
public DenseMatrix(int numRows,
                   int numCols)
```
    Creates a zero matrix of the specified dimensions
    
    Parameters:
    
    numRows - The number of rows in the matrix
    
    numCols - The number of columns in the matrix
  - DenseMatrix
```
public DenseMatrix(int numRows,
                   int numCols,
                   double defaultVal)
```
    Creates a matrix of default val in all cells of the specified dimensions
    
    Parameters:
    
    numRows - The number of rows in the matrix
    
    numCols - The number of columns in the matrix
    
    defaultVal - The value to set all elements to
  - DenseMatrix
```
public DenseMatrix(DenseMatrix m)
```
    Copy constructor that creates a deep copy of the input matrix. Optimized for copying DenseMatrices.
    
    Parameters:
    
    m - The matrix to copy
  - DenseMatrix
```
public DenseMatrix(Matrix m)
```
    Copy constructor that copies any input Matrix -- creating a deep copy of the matrix.
    
    Parameters:
    
    m - The matrix to copy.
  - DenseMatrix
```
public DenseMatrix(double[][] values)
```
    Constructor for creating a dense matrix from a 2-d double array. Copies the values from arr. Input is treated as row-major. While it would be possible to pass in a different length list for each row, that would be bad form. The length of the first row is assumed as the number of columns desired.
    
    Parameters:
    
    values - The 2-d double array that specifies the dimensions and values to be stored in the new matrix.
  - DenseMatrix
```
public DenseMatrix(java.util.List<java.util.List<java.lang.Double>> values)
```
    Constructor for creating a dense matrix from a 2-d double List. Copies the values from arr. Input is treated as row-major. While it would be possible to pass in a different length list for each row, that would be bad form. The length of the first row is assumed as the number of columns desired.
    
    Parameters:
    
    values - The 2-d double array that specifies the dimensions and values to be stored in the matrix.
  - DenseMatrix
```
protected DenseMatrix()
```
    This should never be called by anything or anyone other than Java's serialization code.
- Method Detail
  - clone
```
public final Matrix clone()
```
    Returns a deep copy of this.
    
    Specified by:
    
    clone in interface Matrix
    
    Specified by:
    
    clone in interface Vectorizable
    
    Specified by:
    
    clone in interface Ring<Matrix>
    
    Specified by:
    
    clone in interface CloneableSerializable
    
    Overrides:
    
    clone in class AbstractRing<Matrix>
    
    Returns:
    
    a deep copy of this
  - scaledPlusEquals
```
public void scaledPlusEquals(SparseMatrix other,
                             double scaleFactor)
```
    Type-specific version of scaledPlusEquals for combining whatever type this is with the input sparse matrix.
    
    Parameters:
    
    other - A sparse matrix to add to this
    
    scaleFactor - The amount to scale other by
  - scaledPlusEquals
```
public void scaledPlusEquals(DenseMatrix other,
                             double scaleFactor)
```
    Type-specific version of scaledPlusEquals for combining whatever type this is with the input dense matrix.
    
    Parameters:
    
    other - A dense matrix to add to this
    
    scaleFactor - The amount to scale other by
  - scaledPlusEquals
```
public void scaledPlusEquals(DiagonalMatrix other,
                             double scaleFactor)
```
    Type-specific version of scaledPlusEquals for combining whatever type this is with the input diagonal matrix.
    
    Parameters:
    
    other - A diagonal matrix to add to this
    
    scaleFactor - The amount to scale other by
  - plusEquals
```
public final void plusEquals(SparseMatrix other)
```
    Type-specific version of plusEquals for combining whatever type this is with the input sparse matrix.
    
    Parameters:
    
    other - A sparse matrix to add to this
  - plusEquals
```
public final void plusEquals(DenseMatrix other)
```
    Type-specific version of plusEquals for combining whatever type this is with the input dense matrix.
    
    Parameters:
    
    other - A dense matrix to add to this
  - plusEquals
```
public final void plusEquals(DiagonalMatrix other)
```
    Type-specific version of plusEquals for combining whatever type this is with the input diagonal matrix.
    
    Parameters:
    
    other - A diagonal matrix to add to this
  - minusEquals
```
public final void minusEquals(SparseMatrix other)
```
    Type-specific version of minusEquals for combining whatever type this is with the input sparse matrix.
    
    Parameters:
    
    other - A sparse matrix to subtract from this
  - minusEquals
```
public final void minusEquals(DenseMatrix other)
```
    Type-specific version of minusEquals for combining whatever type this is with the input dense matrix.
    
    Parameters:
    
    other - A dense matrix to subtract from this
  - minusEquals
```
public final void minusEquals(DiagonalMatrix other)
```
    Type-specific version of minusEquals for combining whatever type this is with the input diagonal matrix.
    
    Parameters:
    
    other - A diagonal matrix to subtract from this
  - dotTimesEquals
```
public final void dotTimesEquals(SparseMatrix other)
```
    Type-specific version of dotTimesEquals for combining whatever type this is with the input sparse matrix. NOTE: Calling this method is a bad idea because you end up storing a sparse matrix in a dense representation.
    
    Parameters:
    
    other - A sparse matrix to dot with this
  - dotTimesEquals
```
public final void dotTimesEquals(DenseMatrix other)
```
    Type-specific version of dotTimesEquals for combining whatever type this is with the input dense matrix.
    
    Parameters:
    
    other - A dense matrix to dot with this
  - dotTimesEquals
```
public final void dotTimesEquals(DiagonalMatrix other)
```
    Type-specific version of dotTimesEquals for combining whatever type this is with the input diagonal matrix. NOTE: Calling this method is a really bad idea because you end up storing a diagonal matrix in a dense representation.
    
    Parameters:
    
    other - A diagonal matrix to dot with this
  - times
```
public final Matrix times(SparseMatrix other)
```
    Type-specific version of times for combining whatever type this is with the input sparse matrix.
    
    Parameters:
    
    other - A sparse matrix to multiply with this
  - times
```
public final Matrix times(DenseMatrix other)
```
    Type-specific version of times for combining whatever type this is with the input dense matrix.
    
    Parameters:
    
    other - A dense matrix to multiply with this
  - times
```
public final Matrix times(DiagonalMatrix other)
```
    Type-specific version of times for combining whatever type this is with the input diagonal matrix.
    
    Parameters:
    
    other - A diagonal matrix to multiply with this
  - times
```
public final Vector times(SparseVector vector)
```
    Type-specific version of times for combining whatever type this is with the input sparse vector.
    
    Parameters:
    
    vector - A sparse vector to multiply with this
  - times
```
public final Vector times(DenseVector vector)
```
    Type-specific version of times for combining whatever type this is with the input dense vector.
    
    Parameters:
    
    vector - A dense vector to multiply with this
  - scaleEquals
```
public final void scaleEquals(double scaleFactor)
```
    Description copied from interface: Ring
    
    Inline element-wise scaling of this by scaleFactor
    
    Parameters:
    
    scaleFactor - amount to scale the elements of this
  - getNumRows
```
public final int getNumRows()
```
    Description copied from interface: Matrix
    
    Returns the number of rows in the Matrix
    
    Returns:
    
    Number of rows in the Matrix
  - getNumColumns
```
public final int getNumColumns()
```
    Description copied from interface: Matrix
    
    Returns the number of columns in the Matrix
    
    Returns:
    
    Number of columns in the Matrix
  - get
```
public double get(int rowIndex,
                  int columnIndex)
```
    Description copied from interface: Matrix
    
    Gets the value of the element of the matrix at the zero-based row and column indices. It throws an ArrayIndexOutOfBoundsException if either index is out of range. It is a convenience method for getElement.
    
    Parameters:
    
    rowIndex - The zero-based row index. Must be between 0 (inclusive) and the number of rows (exclusive).
    
    columnIndex - The zero-based column index. Must be between 0 (inclusive) and the number of columns (exclusive).
    
    Returns:
    
    The value at the given row and column in the matrix.
  - getElement
```
public final double getElement(int rowIndex,
                               int columnIndex)
```
    Description copied from interface: Matrix
    
    Gets the Matrix element at the specified zero-based indices throws ArrayIndexOutOfBoundsException if either rowIndex or columnIndex are less than 0, or greater than the number of rows (columns) minus one (0 <= index <= num-1)
    
    Parameters:
    
    rowIndex - Zero-based index into the Matrix
    
    columnIndex - Zero-based index into the Matrix
    
    Returns:
    
    The value at rowIndex, columnIndex
  - set
```
public void set(int rowIndex,
                int columnIndex,
                double value)
```
    Description copied from interface: Matrix
    
    Sets the value of the element of the matrix at the zero-based row and column indices. It throws an ArrayIndexOutOfBoundsException if either index is out of range. It is a convenience method for setElement.
    
    Parameters:
    
    rowIndex - The zero-based row index. Must be between 0 (inclusive) and the number of rows (exclusive).
    
    columnIndex - The zero-based column index. Must be between 0 (inclusive) and the number of columns (exclusive).
    
    value - The value to set at the given row and column in the matrix.
  - setElement
```
public final void setElement(int rowIndex,
                             int columnIndex,
                             double value)
```
    Description copied from interface: Matrix
    
    Sets the Matrix element at the specified zero-based indices throws ArrayIndexOutOfBoundsException if either rowIndex or columnIndex are less than 0, or greater than the number of rows (columns) minus one (0 <= index <= num-1)
    
    Parameters:
    
    rowIndex - Zero-based index into the rows of the Matrix
    
    columnIndex - Zero-based index into the columns of the Matrix
    
    value - Value to set at the specified index
  - getSubMatrix
```
public final Matrix getSubMatrix(int minRow,
                                 int maxRow,
                                 int minColumn,
                                 int maxColumn)
```
    Gets the embedded submatrix inside of the Matrix, specified by the inclusive, zero-based indices such that the result matrix will have size (maxRow-minRow+1) x (maxColum-minCcolumn+1) NOTE: This is inclusive on both end points.
    
    Parameters:
    
    minRow - Zero-based index into the rows of the Matrix, must be less than or equal to maxRow
    
    maxRow - Zero-based index into the rows of the Matrix, must be greater than or equal to minRow
    
    minColumn - Zero-based index into the rows of the Matrix, must be less than or equal to maxColumn
    
    maxColumn - Zero-based index into the rows of the Matrix, must be greater than or equal to minColumn
    
    Returns:
    
    the Matrix of dimension (maxRow-minRow+1)x(maxColumn-minColumn+1)
  - isSymmetric
```
public final boolean isSymmetric(double effectiveZero)
```
    Description copied from interface: Matrix
    
    Determines if the matrix is effectively symmetric
    
    Parameters:
    
    effectiveZero - tolerance to determine symmetry
    
    Returns:
    
    true if effectively symmetric, false otherwise
  - transpose
```
public final Matrix transpose()
```
    Description copied from interface: Matrix
    
    Returns the transpose of this
    
    Returns:
    
    Matrix whose elements are equivalent to: this.getElement(i, j) == this.transpose().getElement(j, i) for any valid i, j.
  - inverse
```
public final Matrix inverse()
```
    Description copied from interface: Matrix
    
    Computes the full-blown inverse of this, which must be a square matrix
    
    Returns:
    
    Inverse of this, such that this.times(this.inverse()) == this.inverse().times(this) ==identity matrix
  - pseudoInverse
```
public final Matrix pseudoInverse(double effectiveZero)
```
    Description copied from interface: Matrix
    
    Computes the effective pseudo-inverse of this, using a rather expensive procedure (SVD)
    
    Parameters:
    
    effectiveZero - effective zero to pass along to the SVD
    
    Returns:
    
    effective pseudo-inverse of this
  - logDeterminant
```
@PublicationReference(author="Wikipedia",title="Triagular Matrix / Special Properties",type=WebPage,year=2013,url="http://en.wikipedia.org/wiki/Triangular_matrix#Special_properties") @PublicationReference(author="Wikipedia",title="Determinant / Relation to Eigenvalues and Trace",type=WebPage,year=2013,url="http://en.wikipedia.org/wiki/Determinant#Relation_to_eigenvalues_and_trace") @PublicationReference(author="Wikipedia",title="Logarithm",type=WebPage,year=2013,url="http://en.wikipedia.org/wiki/Logarithm")
public final ComplexNumber logDeterminant()
```
    Description copied from interface: Matrix
    
    Computes the natural logarithm of the determinant of this. Very computationally intensive. Please THINK LONG AND HARD before invoking this method on sparse matrices, as they have to be converted to a DenseMatrix first.
    
    Returns:
    
    natural logarithm of the determinant of this
  - rank
```
public final int rank(double effectiveZero)
```
    Description copied from interface: Matrix
    
    Computes the effective rank of this, which is the number of linearly independent rows and columns in this. Rank is typically based on the SVD, which is a fairly computationally expensive procedure and should be used carefully
    
    Parameters:
    
    effectiveZero - parameter to pass along to SVD to determine linear dependence
    
    Returns:
    
    rank of this, equivalent to the number of linearly indepenedent rows and columns in this
  - normFrobeniusSquared
```
public double normFrobeniusSquared()
```
    Description copied from interface: Matrix
    
    Compute the squared Frobenius norm of this, which is just a fancy way of saying that I will square each element and add those up.
    
    Returns:
    
    Frobenius norm of this
  - normFrobenius
```
public final double normFrobenius()
```
    Description copied from interface: Matrix
    
    Compute the Frobenius norm of this, which is just a fancy way of saying that I will square each element, add those up, and square root the result. This is probably the most intuitive of the matrix norms
    
    Returns:
    
    Frobenius norm of this
  - isSparse
```
public boolean isSparse()
```
    Description copied from interface: Matrix
    
    Returns true if this matrix has a potentially sparse underlying structure. This can indicate that it is faster to only process the non-zero elements rather than to do dense operations on it. Of course, even with a sparse structure, there may be no zero elements or conversely even with a non-sparse (dense) structure there may be many zero elements.
    
    Returns:
    
    True if the matrix has a potentially sparse structure. Otherwise, false.
  - getEntryCount
```
public int getEntryCount()
```
    Description copied from interface: Matrix
    
    Gets the number of active entries in the matrix. Must be between 0 and the number of rows times the number of columns.
    
    Returns:
    
    The number of active entries in the matrix.
  - svdDecompose
```
public final DenseMatrix.SVD svdDecompose()
```
    Leverages LAPACK to compute the Singular Value Decomposition (SVD) of this. NOTE: Due to LAPACK issues, U and V may be left or right (proper) basis matrices. It they don't count and report the number of row-swaps used when computing the SVD so there's no way to know from the outside without computing the determinant of these matrices (not a cheap operation). Also, note that V is returned, not V^t.
    
    Returns:
    
    The three matrices U, Sigma, and V from the SVD of this
    
    Throws:
    
    java.lang.IllegalStateException - if LAPACK fails to decompose this for an unknown reason.
  - luDecompose
```
public final DenseMatrix.LU luDecompose()
```
    Leverages LAPACK to create the LU decomposition of this. Note: In this case, the row swaps performed when computing the LU factorization are preserved in LU.P so that any -1 scalings of the determinant can be determined.
    
    Returns:
    
    the LU decomposition of this
  - qrDecompose
```
@PublicationReference(author="NetLib",
                      title="DGEQRF",
                      type=WebPage,
                      year=2013,
                      url="http://icl.cs.utk.edu/projectsfiles/f2j/javadoc/org/netlib/lapack/Dgeqrf.html")
public final DenseMatrix.QR qrDecompose()
```
    Leverage LAPACK to compute the QR Decomposition of this. Since LAPACK doesn't return any record of row swaps used to factor this, Q may be a left or right (proper) basis matrix.
    
    Returns:
    
    the QR decomposition (Q is orthonormal basis, R is upper triangular)
  - solve
```
public final Matrix solve(Matrix B)
```
    Description copied from interface: Matrix
    
    Solves for "X" in the equation: this*X = B
    
    Parameters:
    
    B - Must satisfy this.getNumColumns() == B.getNumRows();
    
    Returns:
    
    X Matrix with dimensions (this.getNumColumns() x B.getNumColumns())
  - solve
```
public final Vector solve(Vector b)
```
    Description copied from interface: Matrix
    
    Solves for "x" in the equation: this*x = b
    
    Parameters:
    
    b - must satisfy this.getNumColumns() == b.getDimensionality()
    
    Returns:
    
    x Vector with dimensions (this.getNumColumns())
  - identity
```
public final void identity()
```
    Description copied from interface: Matrix
    
    Formats the matrix as an identity matrix. This does not have to be square.
  - getColumn
```
public final Vector getColumn(int columnIndex)
```
    Description copied from interface: Matrix
    
    Gets the specified column from the zero-based index and returns a vector that corresponds to that column.
    
    Parameters:
    
    columnIndex - zero-based index into the matrix
    
    Returns:
    
    Vector with elements equal to the number of rows in this
  - getRow
```
public final Vector getRow(int rowIndex)
```
    Description copied from interface: Matrix
    
    Gets the specified row from the zero-based index and returns a vector that corresponds to that column
    
    Parameters:
    
    rowIndex - zero-based index into the matrix
    
    Returns:
    
    Vector with elements equal to the number of columns in this
  - convertFromVector
```
public final void convertFromVector(Vector v)
```
    Description copied from interface: Matrix
    
    uploads a matrix from a column-stacked vector of parameters, so that v(k) = A(i,j) = A( k%M, k/M )
    
    Parameters:
    
    v - column-stacked version of this
  - convertToVector
```
public final Vector convertToVector()
```
    Description copied from interface: Matrix
    
    Creates a column-stacked version of this, so that v(k) = A(i,j) = v(j*M+i)
    
    Returns:
    
    column-stacked Vector representing this
  - preTimes
```
public final Vector preTimes(SparseVector vector)
```
    Type-specific version of pre-times for combining whatever type this is with the input sparse vector.
    
    Parameters:
    
    vector - A sparse vector to multiply with this
  - preTimes
```
public final Vector preTimes(DenseVector vector)
```
    Type-specific version of pre-times for combining whatever type this is with the input dense vector.
    
    Parameters:
    
    vector - A dense vector to multiply with this
  - getNonZeroCount
```
public final int getNonZeroCount()
```
    Simple method that computes the number of non-zero elements stored in this.
    
    Returns:
    
    the number of elements in this that are non-zero.
  - getNonZeroPercent
```
public final double getNonZeroPercent()
```
    Returns the percentage of this that is non-zero elements
    
    Returns:
    
    the percentage of this that is non-zero elements
  - getMatrixFactory
```
public MatrixFactory<?> getMatrixFactory()
```
    Description copied from interface: Matrix
    
    Gets a matrix factory, typically one associated with this type of matrix.
    
    Returns:
    
    A matrix factory.
  - plus
```
public final Matrix plus(Matrix other)
```
    Description copied from interface: Ring
    
    Arithmetic addition of this and other
    
    Specified by:
    
    plus in interface Ring<Matrix>
    
    Overrides:
    
    plus in class AbstractRing<Matrix>
    
    Parameters:
    
    other - object to add to this
    
    Returns:
    
    sum of this and other
  - minus
```
public final Matrix minus(Matrix other)
```
    Description copied from interface: Ring
    
    Arithmetic subtraction of other from this
    
    Specified by:
    
    minus in interface Ring<Matrix>
    
    Overrides:
    
    minus in class AbstractRing<Matrix>
    
    Parameters:
    
    other - object to subtract from this
    
    Returns:
    
    difference of this and other
  - dotTimes
```
public final Matrix dotTimes(Matrix other)
```
    Description copied from interface: Ring
    
    Element-wise multiplication of this and other
    
    Specified by:
    
    dotTimes in interface Ring<Matrix>
    
    Overrides:
    
    dotTimes in class AbstractRing<Matrix>
    
    Parameters:
    
    other - elements of other will be multiplied to the corresponding elements of this
    
    Returns:
    
    element-wise multiplication of this and other
  - plusEquals
```
public final void plusEquals(Matrix other)
```
    Description copied from interface: Ring
    
    Inline arithmetic addition of this and other
    
    Specified by:
    
    plusEquals in interface Ring<Matrix>
    
    Overrides:
    
    plusEquals in class AbstractMatrix
    
    Parameters:
    
    other - object to add to this
  - scaledPlusEquals
```
public final void scaledPlusEquals(double scaleFactor,
                                   Matrix other)
```
    Description copied from interface: Ring
    
    Inline arithmetic addition of this and other after element-wise scaling of other by scaleFactor. If this is x, other is y, and scaleFactor is a, then this method is equivalent to x += a * y. It is typically a more efficient way of doing this.plusEquals(other.scale(scaleFactor)) since it can avoid intermediate object creation.
    
    Specified by:
    
    scaledPlusEquals in interface Ring<Matrix>
    
    Overrides:
    
    scaledPlusEquals in class AbstractMatrix
    
    Parameters:
    
    scaleFactor - The scale factor to multiply by the elements of other before adding to the elements of this.
    
    other - Object to scale and then add to this.
  - minusEquals
```
public final void minusEquals(Matrix other)
```
    Description copied from interface: Ring
    
    Inline arithmetic subtraction of other from this
    
    Specified by:
    
    minusEquals in interface Ring<Matrix>
    
    Overrides:
    
    minusEquals in class AbstractMatrix
    
    Parameters:
    
    other - object to subtract from this
  - dotTimesEquals
```
public final void dotTimesEquals(Matrix other)
```
    Description copied from interface: Ring
    
    Inline element-wise multiplication of this and other
    
    Specified by:
    
    dotTimesEquals in interface Ring<Matrix>
    
    Overrides:
    
    dotTimesEquals in class AbstractMatrix
    
    Parameters:
    
    other - elements of other will be multiplied to the corresponding elements of this
  - times
```
public final Matrix times(Matrix other)
```
    Description copied from interface: Matrix
    
    Matrix multiplication of this and matrix, operates like the "*" operator in Matlab
    
    Specified by:
    
    times in interface Matrix
    
    Overrides:
    
    times in class AbstractMatrix
    
    Parameters:
    
    other - this.getNumColumns()==matrix.getNumRows()
    
    Returns:
    
    Matrix multiplication of this and matrix, will this.getNumRows() rows and matrix.getNumColumns() columns
  - times
```
public final Vector times(Vector vector)
```
    Description copied from interface: Matrix
    
    Returns the column vector from the equation return = this * vector
    
    Specified by:
    
    times in interface Matrix
    
    Overrides:
    
    times in class AbstractMatrix
    
    Parameters:
    
    vector - Vector by which to post-multiply this, must have the same number of rows as this
    
    Returns:
    
    Vector with the same dimensionality as the number of rows as this and vector
  - preTimes
```
public final Vector preTimes(Vector vector)
```
    Package-private method that puts the vector * matrix code in the matrix class instead of in the vector class (why should vectors know the internals of matrices?).
    
    Parameters:
    
    vector - The vector to pre-multiply this by
    
    Returns:
    
    The resulting vector from input * this
    
    Throws:
    
    DimensionalityMismatchException - if the input vectors's dimensions doesn't match this's numRows.
  - checkSubmatrixRange
```
protected final void checkSubmatrixRange(int minRow,
                                         int maxRow,
                                         int minCol,
                                         int maxCol)
```
    Helper method checks that the input submatrix range is acceptable for this matrix, including that the max is greater than or equal to the min. Note that the input mins and maxs are inclusive.
    
    Parameters:
    
    minRow - The minimum row to return (inclusive)
    
    maxRow - The maximum row to return (inclusive)
    
    minCol - The minimum column to return (inclusive)
    
    maxCol - The maximum column to return (inclusive)
    
    Throws:
    
    java.lang.ArrayIndexOutOfBoundsException - if the input range is illegal or outside the bounds of this.
  - checkSolveDimensions
```
protected final void checkSolveDimensions(Vector b)
```
    Checks that the input vector has the same dimensionality as this's numRows (otherwise, there can be no solution for Ax = b).
    
    Parameters:
    
    b - The RHS vector
    
    Throws:
    
    java.lang.IllegalArgumentException - if the input's size doesn't match this's numRows
  - checkSolveDimensions
```
protected final void checkSolveDimensions(Matrix b)
```
    Checks that the input matrix has the same numRows as this's numRows (otherwise, there can be no soluation for Ax = b).
    
    Parameters:
    
    b - The RHS matrix
    
    Throws:
    
    java.lang.IllegalArgumentException - if the input's size doesn't match this's numRows
  - toString
```
public final java.lang.String toString(java.text.NumberFormat format)
```
    Description copied from interface: Matrix
    
    Converts the vector to a String, using the given formatter.
    
    Parameters:
    
    format - The number format to use.
    
    Returns:
    
    The String representation of the Matrix.
  - iterator
```
public java.util.Iterator<MatrixEntry> iterator()
```

Class DenseMatrix

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class gov.sandia.cognition.math.matrix.AbstractMatrix

Methods inherited from class gov.sandia.cognition.math.AbstractRing

Methods inherited from class java.lang.Object

Methods inherited from interface gov.sandia.cognition.math.matrix.Matrix

Methods inherited from interface java.lang.Iterable

Methods inherited from interface gov.sandia.cognition.math.Ring

Constructor Detail

DenseMatrix

DenseMatrix

DenseMatrix

DenseMatrix

DenseMatrix

DenseMatrix

DenseMatrix

Method Detail

clone

scaledPlusEquals

scaledPlusEquals

scaledPlusEquals

plusEquals

plusEquals

plusEquals

minusEquals

minusEquals

minusEquals

dotTimesEquals

dotTimesEquals

dotTimesEquals

times

times

times

times

times

scaleEquals

getNumRows

getNumColumns

get

getElement

set

setElement

getSubMatrix

isSymmetric

transpose

inverse

pseudoInverse

logDeterminant

rank

normFrobeniusSquared

normFrobenius

isSparse

getEntryCount

svdDecompose

luDecompose

qrDecompose

solve

solve

identity

getColumn

getRow

convertFromVector

convertToVector

preTimes

preTimes

getNonZeroCount

getNonZeroPercent

getMatrixFactory

plus

minus

dotTimes

plusEquals

scaledPlusEquals

minusEquals

dotTimesEquals

times

times

preTimes