DenseMatrix (librec-core 2.0.0 API)

java.lang.Object
- net.librec.math.structure.DenseMatrix

All Implemented Interfaces:

java.io.Serializable, DataMatrix, DataSet
```
public class DenseMatrix
extends java.lang.Object
implements DataMatrix, java.io.Serializable
```
Data Structure: dense matrix

A big reason that we do not adopt original DenseMatrix from M4J libraray is because the latter using one-dimensional array to store data, which will often cause OutOfMemory exception due to the limit of maximum length of a one-dimensional Java array.

Author:

guoguibing

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

double[][] data
read data

int numColumns
dimension

int numRows
dimension

int topN
dimension

Fields
Modifier and Type	Field and Description
`double[][]`	`data` read data
`int`	`numColumns` dimension
`int`	`numRows` dimension
`int`	`topN` dimension

Constructor Summary

Constructors
Constructor and Description
`DenseMatrix(DenseMatrix mat)` Construct a dense matrix by copying data from a given matrix
`DenseMatrix(double[][] array)` Construct a dense matrix by copying data from a given 2D array
`DenseMatrix(double[][] array, int numRows, int numColumns)` Construct a dense matrix by a shallow copy of a data array
`DenseMatrix(int numRows, int numColumns)` Construct a dense matrix with specified dimensions
`DenseMatrix(int numRows, int numColumns, int topN)` Construct a dense matrix with specified dimensions

Method Summary

Methods
Modifier and Type	Method and Description
`DenseMatrix`	`add(DenseMatrix mat)` Do `A + B` matrix operation
`DenseMatrix`	`add(double val)` Do `A + c` matrix operation, where `c` is a constant.
`void`	`add(int row, int column, double val)` Add a value to entry [row, column]
`DenseMatrix`	`add(SparseMatrix mat)` Do `A + B` matrix operation
`DenseMatrix`	`addEqual(DenseMatrix mat)` Do `A + B` matrix operation
`DenseMatrix`	`addEqual(double val)` Do `A + c` matrix operation, where `c` is a constant.
`DenseMatrix`	`addEqual(SparseMatrix mat)` Do `A + B` matrix operation
`DenseMatrix`	`cholesky()`
`void`	`clear()` Clear and reset all entries to 0.
`DenseMatrix`	`clone()` Make a deep copy of current matrix
`static double`	`colMult(DenseMatrix m, int mcol, DenseMatrix n, int ncol)` Inner product of two column vectors
`DenseVector`	`column(int column)` Return a copy of column data as a dense vector.
`double`	`columnMean(int column)` Compute mean of a column of the current matrix.
`DenseMatrix`	`cov()`
`static DenseMatrix`	`eye(int dim)` Construct an identity matrix
`double`	`get(int row, int column)` Get the value at entry [row, column]
`double[][]`	`getData()`
`DenseMatrix`	`getSubMatrix(int rowStart, int rowEnd, int colStart, int colEnd)` Return a sub matrix of this matrix.
`static DenseMatrix`	`hadamardProduct(DenseMatrix M, DenseMatrix N)` Return Hadamard product of two matrices.
`void`	`init()` Initialize a dense matrix with small random values in (0, 1)
`void`	`init(double range)` Initialize a dense matrix with small random values in (0, range)
`void`	`init(double mean, double sigma)` Initialize a dense matrix with small Guassian values
`DenseMatrix`	`inv()` NOTE: this implementation (adopted from PREA package) is slightly faster than `inverse`, especially when `numRows` is large.
`DenseMatrix`	`inverse()` Deprecated. use `inv` instead which is slightly faster
`static DenseMatrix`	`khatriRaoProduct(DenseMatrix M, DenseMatrix N)` Return Khatri-Rao product of two matrices.
`static DenseMatrix`	`kroneckerProduct(DenseMatrix M, DenseMatrix N)` Return Kronecker product of two arbitrary matrices
`DenseMatrix`	`minus(DenseMatrix mat)` Do `A - B` matrix operation
`DenseMatrix`	`minus(double val)` Do `A - c` matrix operation, where `c` is a constant.
`DenseMatrix`	`minus(SparseMatrix mat)` Do `A - B` matrix operation
`DenseMatrix`	`minusEqual(DenseMatrix mat)` Do `A - B` matrix operation
`DenseMatrix`	`minusEqual(double val)` Do `A - c` matrix operation, where `c` is a constant.
`DenseMatrix`	`minusEqual(SparseMatrix mat)` Do `A - B` matrix operation
`DenseMatrix`	`mult(DenseMatrix mat)` Matrix multiplication with a dense matrix
`DenseVector`	`mult(DenseVector vec)` Do `matrix x vector` between current matrix and a given vector
`DenseMatrix`	`mult(SparseMatrix mat)` Matrix multiplication with a sparse matrix
`static DenseMatrix`	`mult(SparseMatrix sm, DenseMatrix dm)` Matrix multiplication of a sparse matrix by a dense matrix
`DenseVector`	`mult(SparseVector vec)`
`double`	`norm()`
`int`	`numColumns()`
`int`	`numRows()`
`DenseMatrix`	`pinv()`
`static double`	`product(DenseMatrix m, int mrow, DenseMatrix n, int ncol)` Dot product of row x col between two matrices.
`DenseVector`	`row(int rowId)` Return a copy of row data as a dense vector.
`DenseVector`	`row(int rowId, boolean deep)` Return a vector of a specific row.
`static double`	`rowMult(DenseMatrix m, int mrow, DenseMatrix n, int nrow)` Inner product of two row vectors
`DenseMatrix`	`scale(double val)` Return a new matrix by scaling the current matrix.
`DenseMatrix`	`scaleEqual(double val)` Return this matrix by scaling the current matrix.
`void`	`set(int row, int column, double val)` Set a value to entry [row, column]
`void`	`setAll(double val)` Set a value to all entries
`void`	`setRow(int row, DenseVector vals)` Set values of one dense vector to a specific row.
`void`	`setRow(int row, double val)` Set one value to a specific row.
`int`	`size()`
`double`	`sum()`
`double`	`sumOfColumn(int col)` Return the sum of data entries in a column.
`double`	`sumOfRow(int row)` Return the sum of data entries in a row
`SVD`	`svd()`
`java.lang.String`	`toString()`
`DenseMatrix`	`transMult()`
`DenseMatrix`	`transpose()`

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

- Field Detail
  - numRows
```
public int numRows
```
    dimension
  - numColumns
```
public int numColumns
```
    dimension
  - topN
```
public int topN
```
    dimension
  - data
```
public double[][] data
```
    read data
- Constructor Detail
  - DenseMatrix
```
public DenseMatrix(int numRows,
           int numColumns)
```
    Construct a dense matrix with specified dimensions
    
    Parameters:
    numRows - number of rows
    numColumns - number of columns
  - DenseMatrix
```
public DenseMatrix(int numRows,
           int numColumns,
           int topN)
```
    Construct a dense matrix with specified dimensions
    
    Parameters:
    numRows - number of rows
    numColumns - number of columns
    topN - numnber of top N
  - DenseMatrix
```
public DenseMatrix(double[][] array)
```
    Construct a dense matrix by copying data from a given 2D array
    
    Parameters:
    array - data array
  - DenseMatrix
```
public DenseMatrix(double[][] array,
           int numRows,
           int numColumns)
```
    Construct a dense matrix by a shallow copy of a data array
    
    Parameters:
    array - the data array
    numColumns - number of columns
    numRows - number of rows
  - DenseMatrix
```
public DenseMatrix(DenseMatrix mat)
```
    Construct a dense matrix by copying data from a given matrix
    
    Parameters:
    mat - input matrix
- Method Detail
  - clone
```
public DenseMatrix clone()
```
    Make a deep copy of current matrix
    
    Overrides:
    
    clone in class java.lang.Object
    
    Returns:
    a cloned dense matrix
  - eye
```
public static DenseMatrix eye(int dim)
```
    Construct an identity matrix
    
    Parameters:
    dim - dimension
    
    Returns:
    an identity matrix
  - init
```
public void init(double mean,
        double sigma)
```
    Initialize a dense matrix with small Guassian values
    
    NOTE: small initial values make it easier to train a model; otherwise a very small learning rate may be needed (especially when the number of factors is large) which can cause bad performance.
    
    Parameters:
    mean - mean of the gaussian function
    sigma - sigma of the gaussian function
  - init
```
public void init(double range)
```
    Initialize a dense matrix with small random values in (0, range)
    
    Parameters:
    range - max of the range
  - init
```
public void init()
```
    Initialize a dense matrix with small random values in (0, 1)
  - numRows
```
public int numRows()
```
    Returns:
    number of rows
  - numColumns
```
public int numColumns()
```
    Returns:
    number of columns
  - row
```
public DenseVector row(int rowId)
```
    Return a copy of row data as a dense vector.
    
    Parameters:
    rowId - row id
    
    Returns:
    a copy of row data as a dense vector
  - row
```
public DenseVector row(int rowId,
              boolean deep)
```
    Return a vector of a specific row.
    
    Parameters:
    rowId - row id
    deep - whether to copy data or only shallow copy for executing speedup purpose
    
    Returns:
    a vector of a specific row
  - getSubMatrix
```
public DenseMatrix getSubMatrix(int rowStart,
                       int rowEnd,
                       int colStart,
                       int colEnd)
```
    Return a sub matrix of this matrix.
    
    Parameters:
    rowStart - the row index to start
    rowEnd - the row index to end
    colStart - the column index to start
    colEnd - the column index to end
    
    Returns:
    a sub matrix of this matrix
  - column
```
public DenseVector column(int column)
```
    Return a copy of column data as a dense vector.
    
    Parameters:
    column - column id
    
    Returns:
    a copy of column data as a dense vector
  - columnMean
```
public double columnMean(int column)
```
    Compute mean of a column of the current matrix.
    
    Parameters:
    column - column id
    
    Returns:
    mean of a column of the current matrix
  - norm
```
public double norm()
```
    Returns:
    the matrix norm-2
  - rowMult
```
public static double rowMult(DenseMatrix m,
             int mrow,
             DenseMatrix n,
             int nrow)
```
    Inner product of two row vectors
    
    Parameters:
    m - the first matrix
    mrow - row of the first matrix
    n - the second matrix
    nrow - row of the second matrix
    
    Returns:
    inner product of two row vectors
  - colMult
```
public static double colMult(DenseMatrix m,
             int mcol,
             DenseMatrix n,
             int ncol)
```
    Inner product of two column vectors
    
    Parameters:
    m - the first matrix
    mcol - column of the first matrix
    n - the second matrix
    ncol - column of the second matrix
    
    Returns:
    inner product of two column vectors
  - product
```
public static double product(DenseMatrix m,
             int mrow,
             DenseMatrix n,
             int ncol)
                      throws LibrecException
```
    Dot product of row x col between two matrices.
    
    Parameters:
    m - the first matrix
    mrow - row id of the first matrix
    n - the second matrix
    ncol - column id of the second matrix
    
    Returns:
    dot product of row of the first matrix and column of the second matrix
    
    Throws:
    
    LibrecException - if m.numColumns != n.numRows
  - kroneckerProduct
```
public static DenseMatrix kroneckerProduct(DenseMatrix M,
                           DenseMatrix N)
```
    Return Kronecker product of two arbitrary matrices
    
    Parameters:
    M - a dense matrix
    N - an other dense matrix
    
    Returns:
    Kronecker product of two arbitrary matrices
  - khatriRaoProduct
```
public static DenseMatrix khatriRaoProduct(DenseMatrix M,
                           DenseMatrix N)
                                    throws java.lang.Exception
```
    Return Khatri-Rao product of two matrices.
    
    Parameters:
    M - a dense matrix
    N - an other dense matrix
    
    Returns:
    Khatri-Rao product of two matrices
    
    Throws:
    
    java.lang.Exception - if error occurs
  - hadamardProduct
```
public static DenseMatrix hadamardProduct(DenseMatrix M,
                          DenseMatrix N)
                                   throws java.lang.Exception
```
    Return Hadamard product of two matrices.
    
    Parameters:
    M - a dense matrix
    N - an other dense matrix
    
    Returns:
    Hadamard product of two matrices
    
    Throws:
    
    java.lang.Exception - if The dimensions of two matrices are not consistent
  - transMult
```
public DenseMatrix transMult()
```
    Returns:
    the result of A^T A
  - mult
```
public DenseMatrix mult(DenseMatrix mat)
                 throws LibrecException
```
    Matrix multiplication with a dense matrix
    
    Parameters:
    mat - a dense matrix
    
    Returns:
    a dense matrix with results of matrix multiplication
    
    Throws:
    
    LibrecException - if this.numColumns != mat.numRows
  - mult
```
public DenseMatrix mult(SparseMatrix mat)
                 throws LibrecException
```
    Matrix multiplication with a sparse matrix
    
    Parameters:
    mat - a sparse matrix
    
    Returns:
    a dense matrix with results of matrix multiplication
    
    Throws:
    
    LibrecException - if this.numColumns != mat.numRows
  - mult
```
public DenseVector mult(DenseVector vec)
                 throws LibrecException
```
    Do matrix x vector between current matrix and a given vector
    
    Parameters:
    vec - a given vector
    
    Returns:
    a dense vector with the results of matrix x vector
    
    Throws:
    
    LibrecException - if this.numColumns != vec.size
  - mult
```
public DenseVector mult(SparseVector vec)
```
  - mult
```
public static DenseMatrix mult(SparseMatrix sm,
               DenseMatrix dm)
                        throws LibrecException
```
    Matrix multiplication of a sparse matrix by a dense matrix
    
    Parameters:
    sm - a sparse matrix
    dm - a dense matrix
    
    Returns:
    a dense matrix with the results of matrix multiplication
    
    Throws:
    
    LibrecException - if sm.numColumns != dm.numRows
  - get
```
public double get(int row,
         int column)
```
    Get the value at entry [row, column]
    
    Specified by:
    
    get in interface DataMatrix
    
    Parameters:
    column - column index
    row - row index
    
    Returns:
    value at entry [row, column]
  - set
```
public void set(int row,
       int column,
       double val)
```
    Set a value to entry [row, column]
    
    Specified by:
    
    set in interface DataMatrix
    
    Parameters:
    row - row index
    column - column index
    val - the value to be set
  - setAll
```
public void setAll(double val)
```
    Set a value to all entries
    
    Parameters:
    val - the value to be set
  - sumOfRow
```
public double sumOfRow(int row)
```
    Return the sum of data entries in a row
    
    Parameters:
    row - row index
    
    Returns:
    the sum of data entries in a row
  - sumOfColumn
```
public double sumOfColumn(int col)
```
    Return the sum of data entries in a column.
    
    Parameters:
    col - column index
    
    Returns:
    the sum of data entries in a column
  - sum
```
public double sum()
```
    Returns:
    the sum of all data entries
  - scale
```
public DenseMatrix scale(double val)
```
    Return a new matrix by scaling the current matrix.
    
    Parameters:
    val - a given value
    
    Returns:
    a new matrix by scaling the current matrix
  - scaleEqual
```
public DenseMatrix scaleEqual(double val)
```
    Return this matrix by scaling the current matrix.
    
    Parameters:
    val - a given value for scaling
    
    Returns:
    this matrix by scaling the current matrix
  - add
```
public void add(int row,
       int column,
       double val)
```
    Add a value to entry [row, column]
    
    Parameters:
    val - the value to be added
    row - row index
    column - column index
  - add
```
public DenseMatrix add(DenseMatrix mat)
                throws LibrecException
```
    Do A + B matrix operation
    
    Parameters:
    mat - another matrix
    
    Returns:
    a new matrix with results of C = A + B
    
    Throws:
    
    LibrecException - if numRows != mat.numRows or numColumns != mat.numColumns
  - addEqual
```
public DenseMatrix addEqual(DenseMatrix mat)
                     throws LibrecException
```
    Do A + B matrix operation
    
    Parameters:
    mat - another matrix
    
    Returns:
    this matrix with results of A = A + B
    
    Throws:
    
    LibrecException - if numRows != mat.numRows or numColumns != mat.numColumns
  - add
```
public DenseMatrix add(SparseMatrix mat)
                throws LibrecException
```
    Do A + B matrix operation
    
    Parameters:
    mat - another matric
    
    Returns:
    a matrix with results of C = A + B
    
    Throws:
    
    LibrecException - if numRows != mat.numRows or numColumns != mat.numColumns
  - addEqual
```
public DenseMatrix addEqual(SparseMatrix mat)
                     throws LibrecException
```
    Do A + B matrix operation
    
    Parameters:
    mat - another matrix
    
    Returns:
    this matrix with results of A = A + B
    
    Throws:
    
    LibrecException - if numRows != mat.numRows or numColumns != mat.numColumns
  - add
```
public DenseMatrix add(double val)
```
    Do A + c matrix operation, where c is a constant. Each entries will be added by c
    
    Parameters:
    val - the value to be added
    
    Returns:
    a new matrix with results of C = A + c
  - addEqual
```
public DenseMatrix addEqual(double val)
```
    Do A + c matrix operation, where c is a constant. Each entries will be added by c
    
    Parameters:
    val - the value to be added
    
    Returns:
    this matrix with results of A = A + c
  - minus
```
public DenseMatrix minus(DenseMatrix mat)
                  throws LibrecException
```
    Do A - B matrix operation
    
    Parameters:
    mat - another matrix
    
    Returns:
    a new matrix with results of C = A - B
    
    Throws:
    
    LibrecException - if numRows != mat.numRows or numColumns != mat.numColumns
  - minusEqual
```
public DenseMatrix minusEqual(DenseMatrix mat)
                       throws LibrecException
```
    Do A - B matrix operation
    
    Parameters:
    mat - another matrix
    
    Returns:
    this matrix with results of A = A - B
    
    Throws:
    
    LibrecException - if numRows != mat.numRows or numColumns != mat.numColumns
  - minus
```
public DenseMatrix minus(SparseMatrix mat)
                  throws LibrecException
```
    Do A - B matrix operation
    
    Parameters:
    mat - another matrix
    
    Returns:
    a matrix with results of C = A - B
    
    Throws:
    
    LibrecException - if numRows != mat.numRows or numColumns != mat.numColumns
  - minusEqual
```
public DenseMatrix minusEqual(SparseMatrix mat)
                       throws LibrecException
```
    Do A - B matrix operation
    
    Parameters:
    mat - another matrix
    
    Returns:
    this matrix with results of C = A - B
    
    Throws:
    
    LibrecException - if numRows != mat.numRows or numColumns != mat.numColumns
  - minus
```
public DenseMatrix minus(double val)
```
    Do A - c matrix operation, where c is a constant. Each entries will be added by c
    
    Parameters:
    val - the value to for minus
    
    Returns:
    a new matrix with results of C = A - c
  - minusEqual
```
public DenseMatrix minusEqual(double val)
```
    Do A - c matrix operation, where c is a constant. Each entries will be added by c
    
    Parameters:
    val - the value to for minus
    
    Returns:
    this matrix with results of A = A - c
  - cholesky
```
public DenseMatrix cholesky()
```
    Returns:
    the Cholesky decomposition of the current matrix
  - transpose
```
public DenseMatrix transpose()
```
    Returns:
    a transposed matrix of current matrix
  - cov
```
public DenseMatrix cov()
```
    Returns:
    a covariance matrix of the current matrix
  - inverse
```
public DenseMatrix inverse()
```
    Deprecated. use inv instead which is slightly faster
    
    Compute the inverse of a matrix by LU decomposition
    
    Returns:
    the inverse matrix of current matrix
  - inv
```
public DenseMatrix inv()
```
    NOTE: this implementation (adopted from PREA package) is slightly faster than inverse, especially when numRows is large.
    
    Returns:
    the inverse matrix of current matrix
  - pinv
```
public DenseMatrix pinv()
                 throws LibrecException
```
    Returns:
    Moore–Penrose pseudoinverse based on singular value decomposition (SVD)
    
    Throws:
    
    LibrecException - if error occurs during mult
  - svd
```
public SVD svd()
```
  - setRow
```
public void setRow(int row,
          double val)
```
    Set one value to a specific row.
    
    Parameters:
    row - row id
    val - value to be set
  - setRow
```
public void setRow(int row,
          DenseVector vals)
```
    Set values of one dense vector to a specific row.
    
    Parameters:
    row - row id
    vals - values of a dense vector
  - clear
```
public void clear()
```
    Clear and reset all entries to 0.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getData
```
public double[][] getData()
```
    Returns:
    the data
  - size
```
public int size()
```
    Specified by:
    
    size in interface DataSet
    
    Returns:
    number of entries of the dataset

Class DenseMatrix

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

numRows

numColumns

topN

data

Constructor Detail

DenseMatrix

DenseMatrix

DenseMatrix

DenseMatrix

DenseMatrix

Method Detail

clone

eye

init

init

init

numRows

numColumns

row

row

getSubMatrix

column

columnMean

norm

rowMult

colMult

product

kroneckerProduct

khatriRaoProduct

hadamardProduct

transMult

mult

mult

mult

mult

mult

get

set

setAll

sumOfRow

sumOfColumn

sum

scale

scaleEqual

add

add

addEqual

add

addEqual

add

addEqual

minus

minusEqual

minus

minusEqual

minus

minusEqual

cholesky

transpose

cov

inverse

inv

pinv

svd

setRow

setRow

clear

toString

getData

size