SparseMatrix (Java Statistical Analysis Tool 0.0.8 API)

java.lang.Object
- jsat.linear.Matrix
- - jsat.linear.SparseMatrix

All Implemented Interfaces:

Serializable, Cloneable
```
public class SparseMatrix
extends Matrix
```
Creates a new Sparse Matrix where each row is backed by a sparse vector.

This implementation does not support the QR or lup() decompositions.
transposeMultiply(jsat.linear.Matrix, jsat.linear.Matrix, java.util.concurrent.ExecutorService) currently does not use multiple cores.

Author:

Edward Raff

See Also:

Serialized Form

Constructor Summary

Constructors
Modifier	Constructor and Description
	`SparseMatrix(int rows, int cols)` Creates a new sparse matrix
	`SparseMatrix(int rows, int cols, int rowCapacity)` Creates a new sparse matrix
`protected`	`SparseMatrix(SparseMatrix toCopy)` Copy constructor
	`SparseMatrix(SparseVector[] rows)` Creates a new Sparse Matrix backed by the given array of SpareVectors.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`changeSize(int newRows, int newCols)` This method alters the size of a matrix, either adding or subtracting rows from the internal structure of the matrix.
`SparseMatrix`	`clone()`
`int`	`cols()` Returns the number of columns stored in this matrix
`double`	`get(int i, int j)` Returns the value stored at at the matrix position A_i,j
`Vec`	`getRowView(int r)` Obtains a vector that is backed by this, at very little memory cost.
`void`	`increment(int i, int j, double value)` Alters the current matrix at index (i,j) to be equal to A_i,j = A_i,j + value
`boolean`	`isSparce()` Returns `true` if the matrix is sparse, `false` otherwise
`Matrix[]`	`lup()`
`Matrix[]`	`lup(ExecutorService threadPool)`
`void`	`multiply(Matrix B, Matrix C)` Alters the matrix C to be equal to C = C+AB*
`void`	`multiply(Matrix B, Matrix C, ExecutorService threadPool)` Alters the matrix C to be equal to C = C+AB*
`void`	`multiply(Vec b, double z, Vec c)` If this matrix is A_{m x n}, and b has a length of n, and c has a length of m, then this will mutate c to store c = c + Abz
`void`	`multiplyTranspose(Matrix B, Matrix C)` Alters the matrix C to be equal to C = C+AB^T*
`void`	`multiplyTranspose(Matrix B, Matrix C, ExecutorService threadPool)` Alters the matrix C to be equal to C = C+AB^T*
`void`	`mutableAdd(double c)` Alters the current matrix to store the value A+c
`void`	`mutableAdd(double c, ExecutorService threadPool)` Alters the current matrix to store the value A+c
`void`	`mutableAdd(double c, Matrix B)` Alters the current matrix to store the value A+cB*
`void`	`mutableAdd(double c, Matrix B, ExecutorService threadPool)` Alters the current matrix to store the value A+cB*
`void`	`mutableMultiply(double c)` Alters the current matrix to be equal to Ac*
`void`	`mutableMultiply(double c, ExecutorService threadPool)` Alters the current matrix to be equal to Ac*
`void`	`mutableTranspose()` Transposes the current matrix in place, altering its value.
`long`	`nnz()` Returns the number of non zero values stored in this matrix.
`Matrix[]`	`qr()`
`Matrix[]`	`qr(ExecutorService threadPool)`
`int`	`rows()` Returns the number of rows stored in this matrix
`void`	`set(int i, int j, double value)` Sets the value stored at at the matrix position A_i,j
`void`	`swapRows(int r1, int r2)` Alters the current matrix by swapping the values stored in two different rows.
`void`	`transpose(Matrix C)` Overwrites the values stored in matrix C to store the value of A'
`void`	`transposeMultiply(double c, Vec b, Vec x)` Alters the vector x to be equal to x = x + A'bc
`void`	`transposeMultiply(Matrix B, Matrix C)` Alters the matrix C so that C = C + A'B*
`void`	`transposeMultiply(Matrix B, Matrix C, ExecutorService threadPool)` Alters the matrix C so that C = C + A'B*
`void`	`zeroOut()` Alters the current matrix so that all values are equal to zero.

Methods inherited from class jsat.linear.Matrix
add, add, add, add, canBeMutated, canMultiply, copyTo, diag, diagMult, diagMult, equals, equals, eye, getColumn, getColumnView, getRow, isSquare, isSymmetric, isSymmetric, multiply, multiply, multiply, multiply, multiply, multiplyTranspose, multiplyTranspose, mutableAdd, mutableAdd, mutableSubtract, mutableSubtract, mutableSubtract, mutableSubtract, mutableSubtract, mutableSubtract, OuterProductUpdate, OuterProductUpdate, pascal, random, sameDimensions, subtract, subtract, subtract, subtract, toString, transpose, transposeMultiply, transposeMultiply, transposeMultiply, updateRow

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

- Constructor Detail
  - SparseMatrix
```
public SparseMatrix(int rows,
                    int cols,
                    int rowCapacity)
```
    Creates a new sparse matrix
    
    Parameters:
    
    rows - the number of rows for the matrix
    
    cols - the number of columns for the matrix
    
    rowCapacity - the initial capacity for non zero values for each row
  - SparseMatrix
```
public SparseMatrix(SparseVector[] rows)
```
    Creates a new Sparse Matrix backed by the given array of SpareVectors. Altering the array of any object in it will also alter the this matrix.
    
    Parameters:
    
    rows - the array to back this SparseMatrix
  - SparseMatrix
```
public SparseMatrix(int rows,
                    int cols)
```
    Creates a new sparse matrix
    
    Parameters:
    
    rows - the number of rows for the matrix
    
    cols - the number of columns for the matrix
  - SparseMatrix
```
protected SparseMatrix(SparseMatrix toCopy)
```
    Copy constructor
    
    Parameters:
    
    toCopy - the object to copy
- Method Detail
  - mutableAdd
```
public void mutableAdd(double c,
                       Matrix B)
```
    Description copied from class: Matrix
    
    Alters the current matrix to store the value A+c*B
    
    Specified by:
    
    mutableAdd in class Matrix
    
    Parameters:
    
    c - the scalar constant to multiple B by
    
    B - the matrix to add to this
  - mutableAdd
```
public void mutableAdd(double c,
                       Matrix B,
                       ExecutorService threadPool)
```
    Description copied from class: Matrix
    
    Alters the current matrix to store the value A+c*B
    
    Specified by:
    
    mutableAdd in class Matrix
    
    Parameters:
    
    c - the scalar constant to multiple B by
    
    B - the matrix to add to this
    
    threadPool - the source of threads to do computation in parallel
  - mutableAdd
```
public void mutableAdd(double c)
```
    Description copied from class: Matrix
    
    Alters the current matrix to store the value A+c
    
    Specified by:
    
    mutableAdd in class Matrix
    
    Parameters:
    
    c - the scalar constant to add to this
  - mutableAdd
```
public void mutableAdd(double c,
                       ExecutorService threadPool)
```
    Description copied from class: Matrix
    
    Alters the current matrix to store the value A+c
    
    Specified by:
    
    mutableAdd in class Matrix
    
    Parameters:
    
    c - the scalar constant to add to this
    
    threadPool - the source of threads to do computation in parallel
  - multiply
```
public void multiply(Vec b,
                     double z,
                     Vec c)
```
    Description copied from class: Matrix
    
    If this matrix is A_{m x n}, and b has a length of n, and c has a length of m, then this will mutate c to store c = c + A*b*z
    
    Specified by:
    
    multiply in class Matrix
    
    Parameters:
    
    b - the vector to be treated as a colum vector
    
    z - the constant to multiply the A*b value by.
    
    c - where to place the result by addition
  - multiply
```
public void multiply(Matrix B,
                     Matrix C)
```
    Description copied from class: Matrix
    
    Alters the matrix C to be equal to C = C+A*B
    
    Specified by:
    
    multiply in class Matrix
    
    Parameters:
    
    B - the matrix to multiply this with
    
    C - the matrix to add the result to
  - multiply
```
public void multiply(Matrix B,
                     Matrix C,
                     ExecutorService threadPool)
```
    Description copied from class: Matrix
    
    Alters the matrix C to be equal to C = C+A*B
    
    Specified by:
    
    multiply in class Matrix
    
    Parameters:
    
    B - the matrix to multiply this with
    
    C - the matrix to add the result to
    
    threadPool - the source of threads to do computation in parallel
  - mutableMultiply
```
public void mutableMultiply(double c)
```
    Description copied from class: Matrix
    
    Alters the current matrix to be equal to A*c
    
    Specified by:
    
    mutableMultiply in class Matrix
    
    Parameters:
    
    c - the scalar constant to multiply by
  - mutableMultiply
```
public void mutableMultiply(double c,
                            ExecutorService threadPool)
```
    Description copied from class: Matrix
    
    Alters the current matrix to be equal to A*c
    
    Specified by:
    
    mutableMultiply in class Matrix
    
    Parameters:
    
    c - the scalar constant to multiply by
    
    threadPool - the source of threads to do computation in parallel
  - lup
```
public Matrix[] lup()
```
    Specified by:
    
    lup in class Matrix
  - lup
```
public Matrix[] lup(ExecutorService threadPool)
```
    Specified by:
    
    lup in class Matrix
  - qr
```
public Matrix[] qr()
```
    Specified by:
    
    qr in class Matrix
  - qr
```
public Matrix[] qr(ExecutorService threadPool)
```
    Specified by:
    
    qr in class Matrix
  - mutableTranspose
```
public void mutableTranspose()
```
    Description copied from class: Matrix
    
    Transposes the current matrix in place, altering its value. Only valid for square matrices
    
    Specified by:
    
    mutableTranspose in class Matrix
  - transpose
```
public void transpose(Matrix C)
```
    Description copied from class: Matrix
    
    Overwrites the values stored in matrix C to store the value of A'
    
    Specified by:
    
    transpose in class Matrix
    
    Parameters:
    
    C - the matrix to store the transpose of the current matrix
  - transposeMultiply
```
public void transposeMultiply(Matrix B,
                              Matrix C)
```
    Description copied from class: Matrix
    
    Alters the matrix C so that C = C + A'*B
    
    Specified by:
    
    transposeMultiply in class Matrix
    
    Parameters:
    
    B - the matrix to multiply by
    
    C - the matrix to add the result to
  - transposeMultiply
```
public void transposeMultiply(Matrix B,
                              Matrix C,
                              ExecutorService threadPool)
```
    Description copied from class: Matrix
    
    Alters the matrix C so that C = C + A'*B
    
    Specified by:
    
    transposeMultiply in class Matrix
    
    Parameters:
    
    B - the matrix to multiply by
    
    C - the matrix to place the results in
    
    threadPool - the source of threads to do computation in parallel
  - transposeMultiply
```
public void transposeMultiply(double c,
                              Vec b,
                              Vec x)
```
    Description copied from class: Matrix
    
    Alters the vector x to be equal to x = x + A'*b*c
    
    Specified by:
    
    transposeMultiply in class Matrix
    
    Parameters:
    
    c - the scalar constant to multiply by
    
    b - the vector to multiply by
    
    x - the vector the add the result to
  - getRowView
```
public Vec getRowView(int r)
```
    Description copied from class: Matrix
    
    Obtains a vector that is backed by this, at very little memory cost. Mutations to this vector will alter the values stored in the matrix, and vice versa.
    
    Overrides:
    
    getRowView in class Matrix
    
    Parameters:
    
    r - the row to obtain a view of
    
    Returns:
    
    a vector backed by the specified row of the matrix
  - get
```
public double get(int i,
                  int j)
```
    Description copied from class: Matrix
    
    Returns the value stored at at the matrix position A_i,j
    
    Specified by:
    
    get in class Matrix
    
    Parameters:
    
    i - the row, starting from 0
    
    j - the column, starting from 0
    
    Returns:
    
    the value at A_i,j
  - set
```
public void set(int i,
                int j,
                double value)
```
    Description copied from class: Matrix
    
    Sets the value stored at at the matrix position A_i,j
    
    Specified by:
    
    set in class Matrix
    
    Parameters:
    
    i - the row, starting from 0
    
    j - the column, starting from 0
    
    value - the value to place at A_i,j
  - increment
```
public void increment(int i,
                      int j,
                      double value)
```
    Description copied from class: Matrix
    
    Alters the current matrix at index (i,j) to be equal to A_i,j = A_i,j + value
    
    Overrides:
    
    increment in class Matrix
    
    Parameters:
    
    i - the row, starting from 0
    
    j - the column, starting from 0
    
    value - the value to add to the matrix coordinate
  - rows
```
public int rows()
```
    Description copied from class: Matrix
    
    Returns the number of rows stored in this matrix
    
    Specified by:
    
    rows in class Matrix
    
    Returns:
    
    the number of rows stored in this matrix
  - cols
```
public int cols()
```
    Description copied from class: Matrix
    
    Returns the number of columns stored in this matrix
    
    Specified by:
    
    cols in class Matrix
    
    Returns:
    
    the number of columns stored in this matrix
  - isSparce
```
public boolean isSparce()
```
    Description copied from class: Matrix
    
    Returns true if the matrix is sparse, false otherwise
    
    Specified by:
    
    isSparce in class Matrix
    
    Returns:
    
    true if the matrix is sparse, false otherwise
  - swapRows
```
public void swapRows(int r1,
                     int r2)
```
    Description copied from class: Matrix
    
    Alters the current matrix by swapping the values stored in two different rows.
    
    Specified by:
    
    swapRows in class Matrix
    
    Parameters:
    
    r1 - the first row to swap
    
    r2 - the second row to swap
  - zeroOut
```
public void zeroOut()
```
    Description copied from class: Matrix
    
    Alters the current matrix so that all values are equal to zero.
    
    Specified by:
    
    zeroOut in class Matrix
  - clone
```
public SparseMatrix clone()
```
    Specified by:
    
    clone in class Matrix
  - nnz
```
public long nnz()
```
    Description copied from class: Matrix
    
    Returns the number of non zero values stored in this matrix. This is mostly useful for sparse matrices.
    
    Overrides:
    
    nnz in class Matrix
    
    Returns:
    
    the number of non zero values stored in this matrix.
  - changeSize
```
public void changeSize(int newRows,
                       int newCols)
```
    Description copied from class: Matrix
    
    This method alters the size of a matrix, either adding or subtracting rows from the internal structure of the matrix. Every resize call may cause a new allocation internally, and should not be called for excessive changing of a matrix. All added rows/ columns will have values of zero. If a row / column is removed, it is always the bottom/right most row / column removed. Values of the removed rows / columns will be lost.
    
    Specified by:
    
    changeSize in class Matrix
    
    Parameters:
    
    newRows - the new number of rows, must be positive
    
    newCols - the new number of columns, must be positive.
  - multiplyTranspose
```
public void multiplyTranspose(Matrix B,
                              Matrix C)
```
    Description copied from class: Matrix
    
    Alters the matrix C to be equal to C = C+A*B^T
    
    Specified by:
    
    multiplyTranspose in class Matrix
    
    Parameters:
    
    B - the matrix to multiply this with
    
    C - the matrix to add the result to
  - multiplyTranspose
```
public void multiplyTranspose(Matrix B,
                              Matrix C,
                              ExecutorService threadPool)
```
    Description copied from class: Matrix
    
    Alters the matrix C to be equal to C = C+A*B^T
    
    Specified by:
    
    multiplyTranspose in class Matrix
    
    Parameters:
    
    B - the matrix to multiply this with
    
    C - the matrix to add the result to
    
    threadPool - the source of threads to do computation in parallel

Class SparseMatrix

Constructor Summary

Method Summary

Methods inherited from class jsat.linear.Matrix

Methods inherited from class java.lang.Object

Constructor Detail

SparseMatrix

SparseMatrix

SparseMatrix

SparseMatrix

Method Detail

mutableAdd

mutableAdd

mutableAdd

mutableAdd

multiply

multiply

multiply

mutableMultiply

mutableMultiply

lup

lup

qr

qr

mutableTranspose

transpose

transposeMultiply

transposeMultiply

transposeMultiply

getRowView

get

set

increment

rows

cols

isSparce

swapRows

zeroOut

clone

nnz

changeSize

multiplyTranspose

multiplyTranspose