Matrix

java.lang.Object
- edu.umich.eecs.april.jmat.Matrix

```
public class Matrix
extends java.lang.Object
```
Matrix class supporting dense and sparse matrices.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DENSE`
`(package private) int`	`m`
`(package private) int`	`n`
`(package private) int`	`options`
`(package private) static java.util.Random`	`rand`
`(package private) Vec[]`	`rows`
`static int`	`SPARSE`

Constructor Summary

Constructors
Constructor and Description

Matrix(double v)

Matrix(double[][] A)

Matrix(int m, int n)

Matrix(int m, int n, int options)

Constructors
Constructor and Description
`Matrix(double v)`
`Matrix(double[][] A)`
`Matrix(int m, int n)`
`Matrix(int m, int n, int options)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`Matrix`	`coerceOption(int options)`
`static Matrix`	`columnMatrix(double[] v)`
`static Matrix`	`columnPackedMatrix(double[] v, int m, int n)` Create a matrix from the column-packed vector.
`Matrix`	`copy()`
`Matrix`	`copy(int row0, int row1, int col0, int col1)`
`double[][]`	`copyArray()`
`double[][]`	`copyArray(int i0, int j0, int tm, int tn)` Copy the submatrix beginning at (i0,j0) with m rows and n columns
`void`	`copyArray(int i0, int j0, int tm, int tn, double[][] A)` Copy the submatrix beginning at (i0,j0) with m rows and n columns
`double[]`	`copyAsVector()`
`Matrix`	`copyPermuteColumns(int[] perm)`
`Matrix`	`copyPermuteRowsAndColumns(int[] perm)`
`void`	`copyToArray(double[][] A)`
`double`	`det()`
`static Matrix`	`diag(double[] v)`
`boolean`	`equals(Matrix M)`
`boolean`	`equals(Matrix M, double eps)`
`double`	`get(int pos)`
`double`	`get(int row, int col)`
`Vec`	`getColumn(int col)` Create a new Vec containing a copy of the column.
`int`	`getColumnDimension()`
`double[]`	`getColumnPackedCopy()`
`int`	`getNz()`
`double`	`getNzFrac()`
`int`	`getOptions()`
`Vec`	`getRow(int row)` The Vec returned is a LIVE view of the matrix.
`int`	`getRowDimension()`
`static Matrix`	`identity(int m, int n)`
`Matrix`	`inverse()`
`void`	`inversePermuteRows(int[] pivot)`
`boolean`	`isSparse()`
`double`	`logDet()`
`(package private) Vec`	`makeVec(int length)`
`Matrix`	`minus(Matrix B)`
`void`	`minusEquals(int i0, int j0, double[][] v)`
`void`	`minusEquals(int i0, int j0, Matrix M)`
`void`	`minusEquals(Matrix M)`
`double`	`normF()`
`static Matrix`	`outerProduct(double[] x, double[] y)`
`void`	`permuteRows(int[] perm)`
`Matrix`	`plus(Matrix B)`
`void`	`plusEquals(double[][] v)`
`void`	`plusEquals(int i, int j, double v)`
`void`	`plusEquals(int i0, int j0, double[][] v)`
`void`	`plusEquals(int i0, int j0, Matrix M)`
`void`	`plusEquals(Matrix M)`
`void`	`plusEqualsColumnVector(double[] v)`
`void`	`plusEqualsColumnVector(int i0, int j0, double[] v)`
`void`	`print()`
`static Matrix`	`random(int m, int n)`
`static Matrix`	`read(java.io.BufferedReader ins)` Create a new matrix whose dimensions are given on the first two lines (rows on the first line, cols on the second line), followed by each element of the matrix on a line by itself (row major ordering).
`void`	`resize(int newrows, int newcols)` Truncate or add zeros as appropriate.
`static Matrix`	`rowMatrix(double[] v)`
`void`	`set(int pos, double v)`
`void`	`set(int row, int col, double v)`
`void`	`set(int row, int col, double[][] v)`
`void`	`setRow(int row, Vec v)` Use with extreme caution.
`Matrix`	`solve(Matrix B)`
`void`	`swapRows(int a, int b)`
`Matrix`	`times(double v)`
`double[]`	`times(double[] B)`
`Matrix`	`times(Matrix B)`
`void`	`timesEquals(double v)`
`void`	`timesEquals(int i, int j, double v)`
`Matrix`	`timesTranspose(Matrix BT)`
`java.lang.String`	`toString()`
`double`	`trace()`
`Matrix`	`transpose()`
`double[]`	`transposeTimes(double[] B)`
`Matrix`	`upperRight()`
`Matrix`	`upperRightTranspose()`
`void`	`write(java.io.BufferedWriter outs)` Writes matrix data in a format compatible with the read() method.
`void`	`writeMatlab(java.io.BufferedWriter outs, java.lang.String matname)` Writes the matrix in a form that can be easily executed by matlab in a way that is efficient for sparse matrices.

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

Field Detail

DENSE
```
public static final int DENSE
```
See Also:

Constant Field Values

SPARSE
```
public static final int SPARSE
```
See Also:

Constant Field Values

m
```
int m
```

n
```
int n
```

options
```
int options
```

rows
```
Vec[] rows
```

rand
```
static java.util.Random rand
```

Constructor Detail

Matrix
```
public Matrix(double v)
```

Matrix

public Matrix(int m,
              int n)

Matrix

public Matrix(int m,
              int n,
              int options)

Matrix
```
public Matrix(double[][] A)
```

Method Detail

makeVec
```
final Vec makeVec(int length)
```

diag

public static Matrix diag(double[] v)

rowMatrix

public static Matrix rowMatrix(double[] v)

columnMatrix

public static Matrix columnMatrix(double[] v)

outerProduct

public static Matrix outerProduct(double[] x,
                                  double[] y)

coerceOption

public Matrix coerceOption(int options)

copy
```
public Matrix copy()
```

copyArray
```
public double[][] copyArray()
```

copyToArray

public void copyToArray(double[][] A)

copyArray

public double[][] copyArray(int i0,
                            int j0,
                            int tm,
                            int tn)

Copy the submatrix beginning at (i0,j0) with m rows and n columns

copyArray

public void copyArray(int i0,
                      int j0,
                      int tm,
                      int tn,
                      double[][] A)

Copy the submatrix beginning at (i0,j0) with m rows and n columns

copyAsVector
```
public double[] copyAsVector()
```

copy

public Matrix copy(int row0,
                   int row1,
                   int col0,
                   int col1)

identity

public static Matrix identity(int m,
                              int n)

random

public static Matrix random(int m,
                            int n)

getRowDimension
```
public int getRowDimension()
```

getColumnDimension
```
public int getColumnDimension()
```

getOptions
```
public int getOptions()
```

get
```
public double get(int pos)
```

set

public void set(int pos,
                double v)

get

public double get(int row,
                  int col)

set

public void set(int row,
                int col,
                double v)

set

public void set(int row,
                int col,
                double[][] v)

getColumn
```
public Vec getColumn(int col)
```
Create a new Vec containing a copy of the column. Changes to the Vec do NOT affect the Matrix.

getRow
```
public Vec getRow(int row)
```
The Vec returned is a LIVE view of the matrix. Changes to it affect the matrix. (This is NOT the case for getColumn).

setRow

public void setRow(int row,
                   Vec v)

Use with extreme caution.

isSparse
```
public boolean isSparse()
```

getNz
```
public int getNz()
```

getNzFrac
```
public double getNzFrac()
```

clear
```
public void clear()
```

equals
```
public boolean equals(Matrix M)
```

equals

public boolean equals(Matrix M,
                      double eps)

print
```
public void print()
```

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

times
```
public Matrix times(double v)
```

times
```
public Matrix times(Matrix B)
```

transposeTimes

public double[] transposeTimes(double[] B)

timesTranspose

public Matrix timesTranspose(Matrix BT)

times
```
public double[] times(double[] B)
```

det
```
public double det()
```

logDet
```
public double logDet()
```

getColumnPackedCopy
```
public double[] getColumnPackedCopy()
```

columnPackedMatrix

public static Matrix columnPackedMatrix(double[] v,
                                        int m,
                                        int n)

Create a matrix from the column-packed vector. The matrix has m rows and n columns.

timesEquals
```
public void timesEquals(double v)
```

timesEquals

public void timesEquals(int i,
                        int j,
                        double v)

plus
```
public Matrix plus(Matrix B)
```

minus
```
public Matrix minus(Matrix B)
```

plusEquals

public void plusEquals(int i,
                       int j,
                       double v)

plusEquals
```
public void plusEquals(double[][] v)
```

plusEquals

public void plusEquals(int i0,
                       int j0,
                       double[][] v)

plusEqualsColumnVector

public void plusEqualsColumnVector(double[] v)

plusEqualsColumnVector

public void plusEqualsColumnVector(int i0,
                                   int j0,
                                   double[] v)

plusEquals
```
public void plusEquals(Matrix M)
```

minusEquals

public void minusEquals(int i0,
                        int j0,
                        double[][] v)

minusEquals

public void minusEquals(int i0,
                        int j0,
                        Matrix M)

minusEquals
```
public void minusEquals(Matrix M)
```

plusEquals

public void plusEquals(int i0,
                       int j0,
                       Matrix M)

trace
```
public double trace()
```

normF
```
public double normF()
```

solve
```
public Matrix solve(Matrix B)
```

swapRows

public void swapRows(int a,
                     int b)

permuteRows
```
public void permuteRows(int[] perm)
```

copyPermuteColumns

public Matrix copyPermuteColumns(int[] perm)

copyPermuteRowsAndColumns

public Matrix copyPermuteRowsAndColumns(int[] perm)

inversePermuteRows

public void inversePermuteRows(int[] pivot)

transpose
```
public Matrix transpose()
```

upperRightTranspose
```
public Matrix upperRightTranspose()
```

upperRight
```
public Matrix upperRight()
```

inverse
```
public Matrix inverse()
```

resize

public void resize(int newrows,
                   int newcols)

Truncate or add zeros as appropriate.

write
```
public void write(java.io.BufferedWriter outs)
           throws java.io.IOException
```
Writes matrix data in a format compatible with the read() method.

Throws:

java.io.IOException

read
```
public static Matrix read(java.io.BufferedReader ins)
                   throws java.io.IOException
```
Create a new matrix whose dimensions are given on the first two lines (rows on the first line, cols on the second line), followed by each element of the matrix on a line by itself (row major ordering).

Throws:

java.io.IOException

writeMatlab
```
public void writeMatlab(java.io.BufferedWriter outs,
                        java.lang.String matname)
                 throws java.io.IOException
```
Writes the matrix in a form that can be easily executed by matlab in a way that is efficient for sparse matrices.

Throws:

java.io.IOException

Class Matrix

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DENSE

SPARSE

m

n

options

rows

rand

Constructor Detail

Matrix

Matrix

Matrix

Matrix

Method Detail

makeVec

diag

rowMatrix

columnMatrix

outerProduct

coerceOption

copy

copyArray

copyToArray

copyArray

copyArray

copyAsVector

copy

identity

random

getRowDimension

getColumnDimension

getOptions

get

set

get

set

set

getColumn

getRow

setRow

isSparse

getNz

getNzFrac

clear

equals

equals

print

toString

times

times

transposeTimes

timesTranspose

times

det

logDet

getColumnPackedCopy

columnPackedMatrix

timesEquals

timesEquals

plus

minus

plusEquals

plusEquals

plusEquals

plusEqualsColumnVector

plusEqualsColumnVector

plusEquals

minusEquals

minusEquals

minusEquals

plusEquals

trace

normF

solve

swapRows