java.lang.Object
- no.uib.cipr.matrix.AbstractMatrix

All Implemented Interfaces:

java.lang.Iterable<MatrixEntry>, Matrix

Direct Known Subclasses:

BandMatrix, CompColMatrix, CompDiagMatrix, CompRowMatrix, DenseMatrix, DistColMatrix, DistRowMatrix, FlexCompColMatrix, FlexCompRowMatrix, LowerSymmBandMatrix, LowerSymmDenseMatrix, LowerSymmPackMatrix, LowerTriangBandMatrix, LowerTriangDenseMatrix, LowerTriangPackMatrix, SymmTridiagMatrix, TridiagMatrix, UpperSymmBandMatrix, UpperSymmDenseMatrix, UpperSymmPackMatrix, UpperTriangBandMatrix, UpperTriangDenseMatrix, UpperTriangPackMatrix
```
public abstract class AbstractMatrix
extends java.lang.Object
implements Matrix
```
Partial implementation of Matrix. The following methods throw UnsupportedOperationException, and should be overridden by a subclass:
- get(int,int)
- set(int,int,double)
- copy
- All the direct solution methods
For the rest of the methods, simple default implementations using a matrix iterator has been provided. There are some kernel operations which the simpler operations forward to, for instance, mult(Matrix,Matrix) forwards to multAdd(double,Matrix,Matrix). Subclasses can thus focus on overriding the kernel operations, which are:
- multAdd(double,Vector,Vector) and transMultAdd(double,Vector,Vector).
- rank1(double,Vector,Vector) and rank1(double,Vector,Vector).
- multAdd(double,Matrix,Matrix), transAmultAdd(double,Matrix,Matrix), transBmultAdd(double,Matrix,Matrix), and transABmultAdd(double,Matrix,Matrix).
- scale(double).
- set(double,Matrix) and add(double,Matrix).
- transpose and transpose(Matrix).
- All the norms.
Finally, a default iterator is provided by this class, which works by calling the get function. A tailored replacement should be used by subclasses.

Nested Class Summary
- Nested classes/interfaces inherited from interface no.uib.cipr.matrix.Matrix
  Matrix.Norm

Field Summary

Fields
Modifier and Type Field Description

protected int numColumns
Number of columns

protected int numRows
Number of rows

Constructor Summary

Constructors
Modifier	Constructor	Description
`protected`	`AbstractMatrix(int numRows, int numColumns)`	Constructor for AbstractMatrix
`protected`	`AbstractMatrix(Matrix A)`	Constructor for AbstractMatrix, same size as A.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Matrix`	`add(double alpha, Matrix B)`	`A = alpha*B + A`.
`void`	`add(int row, int column, double value)`	`A(row,column) += value`
`Matrix`	`add(Matrix B)`	`A = B + A`.
`protected void`	`check(int row, int column)`	Checks the passed row and column indices
`protected void`	`checkMultAdd(Matrix B, Matrix C)`	Checks the arguments to `mult` and `multAdd`
`protected void`	`checkMultAdd(Vector x, Vector y)`	Checks the arguments to `mult` and `multAdd`
`protected void`	`checkRank1(Matrix C)`	Checks that a matrix rank1 update is possible for the given matrix
`protected void`	`checkRank1(Vector x, Vector y)`	Checks that a vector rank1 update is possible for the given vectors
`protected void`	`checkRank2(Matrix B, Matrix C)`	Checks that a rank2 update is legal for the given arguments
`protected void`	`checkRank2(Vector x, Vector y)`	Checks that a vector rank2 update is legal with the given vectors
`protected void`	`checkSize(Matrix B)`	Checks that the sizes of this matrix and the given conform
`protected void`	`checkSolve(Matrix B, Matrix X)`	Checks that a matrix inversion is legal for the given arguments.
`protected void`	`checkSolve(Vector b, Vector x)`	Checks that a matrix inversion is legal for the given arguments.
`protected void`	`checkTransABmultAdd(Matrix B, Matrix C)`	Checks the arguments to `transABmultAdd` and `transABmultAdd`
`protected void`	`checkTransAmultAdd(Matrix B, Matrix C)`	Checks the arguments to `transAmult` and `transAmultAdd`
`protected void`	`checkTransBmultAdd(Matrix B, Matrix C)`	Checks the arguments to `transBmult` and `transBmultAdd`
`protected void`	`checkTransMultAdd(Vector x, Vector y)`	Checks the arguments to `transMult` and `transMultAdd`
`protected void`	`checkTranspose()`	Checks that the matrix may be transposed
`protected void`	`checkTranspose(Matrix B)`	Checks that this matrix can be transposed into the given matrix
`protected void`	`checkTransRank1(Matrix C)`	Checks that a transposed rank1 update is leagal with the given argument
`protected void`	`checkTransRank2(Matrix B, Matrix C)`	Checks that a transposed rank2 update is leagal with the given arguments
`Matrix`	`copy()`	Creates a deep copy of the matrix
`double`	`get(int row, int column)`	Returns `A(row,column)`
`boolean`	`isSquare()`	Returns true if the matrix is square
`java.util.Iterator<MatrixEntry>`	`iterator()`
`protected double`	`max()`	Returns the largest absolute value
`protected double`	`max(double[] x)`	Returns the largest element of the passed array
`Matrix`	`mult(double alpha, Matrix B, Matrix C)`	`C = alphaAB`
`Vector`	`mult(double alpha, Vector x, Vector y)`	`y = alphaAx`
`Matrix`	`mult(Matrix B, Matrix C)`	`C = A*B`
`Vector`	`mult(Vector x, Vector y)`	`y = A*x`
`Matrix`	`multAdd(double alpha, Matrix B, Matrix C)`	`C = alphaAB + C`
`Vector`	`multAdd(double alpha, Vector x, Vector y)`	`y = alphaAx + y`
`Matrix`	`multAdd(Matrix B, Matrix C)`	`C = A*B + C`
`Vector`	`multAdd(Vector x, Vector y)`	`y = A*x + y`
`double`	`norm(Matrix.Norm type)`	Computes the given norm of the matrix
`protected double`	`norm1()`	Computes the 1 norm
`protected double`	`normF()`	Computes the Frobenius norm.
`protected double`	`normInf()`	Computes the infinity norm
`int`	`numColumns()`	Number of columns in the matrix
`int`	`numRows()`	Number of rows in the matrix
`Matrix`	`rank1(double alpha, Matrix C)`	`A = alphaCC^T + A`.
`Matrix`	`rank1(double alpha, Vector x)`	`A = alphaxx^T + A`.
`Matrix`	`rank1(double alpha, Vector x, Vector y)`	`A = alphaxy^T + A`.
`Matrix`	`rank1(Matrix C)`	`A = C*C^T + A`.
`Matrix`	`rank1(Vector x)`	`A = x*x^T + A`.
`Matrix`	`rank1(Vector x, Vector y)`	`A = x*y^T + A`.
`Matrix`	`rank2(double alpha, Matrix B, Matrix C)`	`A = alphaBC^T + alphaCB^T + A`.
`Matrix`	`rank2(double alpha, Vector x, Vector y)`	`A = alphaxy^T + alphayx^T + A`.
`Matrix`	`rank2(Matrix B, Matrix C)`	`A = BC^T + CB^T + A`.
`Matrix`	`rank2(Vector x, Vector y)`	`A = xy^T + yx^T + A`.
`Matrix`	`scale(double alpha)`	`A = alpha*A`
`Matrix`	`set(double alpha, Matrix B)`	`A=alpha*B`.
`void`	`set(int row, int column, double value)`	`A(row,column) = value`
`Matrix`	`set(Matrix B)`	`A=B`.
`Matrix`	`solve(Matrix B, Matrix X)`	`X = A\B`.
`Vector`	`solve(Vector b, Vector x)`	`x = A\b`.
`java.lang.String`	`toString()`
`Matrix`	`transABmult(double alpha, Matrix B, Matrix C)`	`C = alphaA^TB^T`
`Matrix`	`transABmult(Matrix B, Matrix C)`	`C = A^T*B^T`
`Matrix`	`transABmultAdd(double alpha, Matrix B, Matrix C)`	`C = alphaA^TB^T + C`
`Matrix`	`transABmultAdd(Matrix B, Matrix C)`	`C = A^T*B^T + C`
`Matrix`	`transAmult(double alpha, Matrix B, Matrix C)`	`C = alphaA^TB`
`Matrix`	`transAmult(Matrix B, Matrix C)`	`C = A^T*B`
`Matrix`	`transAmultAdd(double alpha, Matrix B, Matrix C)`	`C = alphaA^TB + C`
`Matrix`	`transAmultAdd(Matrix B, Matrix C)`	`C = A^T*B + C`
`Matrix`	`transBmult(double alpha, Matrix B, Matrix C)`	`C = alphaAB^T`
`Matrix`	`transBmult(Matrix B, Matrix C)`	`C = A*B^T`
`Matrix`	`transBmultAdd(double alpha, Matrix B, Matrix C)`	`C = alphaAB^T + C`
`Matrix`	`transBmultAdd(Matrix B, Matrix C)`	`C = A*B^T + C`
`Vector`	`transMult(double alpha, Vector x, Vector y)`	`y = alphaA^Tx`
`Vector`	`transMult(Vector x, Vector y)`	`y = A^T*x`
`Vector`	`transMultAdd(double alpha, Vector x, Vector y)`	`y = alphaA^Tx + y`
`Vector`	`transMultAdd(Vector x, Vector y)`	`y = A^T*x + y`
`Matrix`	`transpose()`	Transposes the matrix in-place.
`Matrix`	`transpose(Matrix B)`	Sets the tranpose of this matrix into `B`.
`Matrix`	`transRank1(double alpha, Matrix C)`	`A = alphaC^TC + A` The matrices must be square and of the same size
`Matrix`	`transRank1(Matrix C)`	`A = C^T*C + A` The matrices must be square and of the same size
`Matrix`	`transRank2(double alpha, Matrix B, Matrix C)`	`A = alphaB^TC + alphaC^TB + A`.
`Matrix`	`transRank2(Matrix B, Matrix C)`	`A = B^TC + C^TB + A`.
`Matrix`	`transSolve(Matrix B, Matrix X)`	`X = A^T\B`.
`Vector`	`transSolve(Vector b, Vector x)`	`x = A^T\b`.
`Matrix`	`zero()`	Zeros all the entries in the matrix, while preserving any underlying structure.

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

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

- Field Detail
  - numRows
```
protected int numRows
```
    Number of rows
  - numColumns
```
protected int numColumns
```
    Number of columns
- Constructor Detail
  - AbstractMatrix
```
protected AbstractMatrix(int numRows,
                         int numColumns)
```
    Constructor for AbstractMatrix
  - AbstractMatrix
```
protected AbstractMatrix(Matrix A)
```
    Constructor for AbstractMatrix, same size as A. The invoking constructor should set this matrix equal the argument matrix
- Method Detail
  - numRows
```
public int numRows()
```
    Description copied from interface: Matrix
    
    Number of rows in the matrix
    
    Specified by:
    
    numRows in interface Matrix
  - numColumns
```
public int numColumns()
```
    Description copied from interface: Matrix
    
    Number of columns in the matrix
    
    Specified by:
    
    numColumns in interface Matrix
  - isSquare
```
public boolean isSquare()
```
    Description copied from interface: Matrix
    
    Returns true if the matrix is square
    
    Specified by:
    
    isSquare in interface Matrix
  - set
```
public void set(int row,
                int column,
                double value)
```
    Description copied from interface: Matrix
    
    A(row,column) = value
    
    Specified by:
    
    set in interface Matrix
  - add
```
public void add(int row,
                int column,
                double value)
```
    Description copied from interface: Matrix
    
    A(row,column) += value
    
    Specified by:
    
    add in interface Matrix
  - get
```
public double get(int row,
                  int column)
```
    Description copied from interface: Matrix
    
    Returns A(row,column)
    
    Specified by:
    
    get in interface Matrix
  - check
```
protected void check(int row,
                     int column)
```
    Checks the passed row and column indices
  - copy
```
public Matrix copy()
```
    Description copied from interface: Matrix
    
    Creates a deep copy of the matrix
    
    Specified by:
    
    copy in interface Matrix
    
    Returns:
    
    A
  - zero
```
public Matrix zero()
```
    Description copied from interface: Matrix
    
    Zeros all the entries in the matrix, while preserving any underlying structure. Useful for general, unstructured matrices.
    
    Specified by:
    
    zero in interface Matrix
    
    Returns:
    
    A
  - mult
```
public Vector mult(Vector x,
                   Vector y)
```
    Description copied from interface: Matrix
    
    y = A*x
    
    Specified by:
    
    mult in interface Matrix
    
    Parameters:
    
    x - Vector of size A.numColumns()
    
    y - Vector of size A.numRows()
    
    Returns:
    
    y
  - mult
```
public Vector mult(double alpha,
                   Vector x,
                   Vector y)
```
    Description copied from interface: Matrix
    
    y = alpha*A*x
    
    Specified by:
    
    mult in interface Matrix
    
    x - Vector of size A.numColumns()
    
    y - Vector of size A.numRows()
    
    Returns:
    
    y
  - multAdd
```
public Vector multAdd(Vector x,
                      Vector y)
```
    Description copied from interface: Matrix
    
    y = A*x + y
    
    Specified by:
    
    multAdd in interface Matrix
    
    Parameters:
    
    x - Vector of size A.numColumns()
    
    y - Vector of size A.numRows()
    
    Returns:
    
    y
  - multAdd
```
public Vector multAdd(double alpha,
                      Vector x,
                      Vector y)
```
    Description copied from interface: Matrix
    
    y = alpha*A*x + y
    
    Specified by:
    
    multAdd in interface Matrix
    
    x - Vector of size A.numColumns()
    
    y - Vector of size A.numRows()
    
    Returns:
    
    y
  - checkMultAdd
```
protected void checkMultAdd(Vector x,
                            Vector y)
```
    Checks the arguments to mult and multAdd
  - transMult
```
public Vector transMult(Vector x,
                        Vector y)
```
    Description copied from interface: Matrix
    
    y = A^T*x
    
    Specified by:
    
    transMult in interface Matrix
    
    Parameters:
    
    x - Vector of size A.numRows()
    
    y - Vector of size A.numColumns()
    
    Returns:
    
    y
  - transMult
```
public Vector transMult(double alpha,
                        Vector x,
                        Vector y)
```
    Description copied from interface: Matrix
    
    y = alpha*A^T*x
    
    Specified by:
    
    transMult in interface Matrix
    
    x - Vector of size A.numRows()
    
    y - Vector of size A.numColumns()
    
    Returns:
    
    y
  - transMultAdd
```
public Vector transMultAdd(Vector x,
                           Vector y)
```
    Description copied from interface: Matrix
    
    y = A^T*x + y
    
    Specified by:
    
    transMultAdd in interface Matrix
    
    Parameters:
    
    x - Vector of size A.numRows()
    
    y - Vector of size A.numColumns()
    
    Returns:
    
    y
  - transMultAdd
```
public Vector transMultAdd(double alpha,
                           Vector x,
                           Vector y)
```
    Description copied from interface: Matrix
    
    y = alpha*A^T*x + y
    
    Specified by:
    
    transMultAdd in interface Matrix
    
    x - Vector of size A.numRows()
    
    y - Vector of size A.numColumns()
    
    Returns:
    
    y
  - checkTransMultAdd
```
protected void checkTransMultAdd(Vector x,
                                 Vector y)
```
    Checks the arguments to transMult and transMultAdd
  - solve
```
public Vector solve(Vector b,
                    Vector x)
```
    Description copied from interface: Matrix
    
    x = A\b. Not all matrices support this operation, those that do not throw UnsupportedOperationException. Note that it is often more efficient to use a matrix decomposition and its associated solver
    
    Specified by:
    
    solve in interface Matrix
    
    Parameters:
    
    b - Vector of size A.numRows()
    
    x - Vector of size A.numColumns()
    
    Returns:
    
    x
  - transSolve
```
public Vector transSolve(Vector b,
                         Vector x)
```
    Description copied from interface: Matrix
    
    x = A^T\b. Not all matrices support this operation, those that do not throw UnsupportedOperationException. Note that it is often more efficient to use a matrix decomposition and its associated solver
    
    Specified by:
    
    transSolve in interface Matrix
    
    Parameters:
    
    b - Vector of size A.numColumns()
    
    x - Vector of size A.numRows()
    
    Returns:
    
    x
  - checkSolve
```
protected void checkSolve(Vector b,
                          Vector x)
```
    Checks that a matrix inversion is legal for the given arguments. This is for the square case, not for least-squares problems
  - rank1
```
public Matrix rank1(Vector x)
```
    Description copied from interface: Matrix
    
    A = x*x^T + A. The matrix must be square, and the vector of the same length
    
    Specified by:
    
    rank1 in interface Matrix
    
    Returns:
    
    A
  - rank1
```
public Matrix rank1(double alpha,
                    Vector x)
```
    Description copied from interface: Matrix
    
    A = alpha*x*x^T + A. The matrix must be square, and the vector of the same length
    
    Specified by:
    
    rank1 in interface Matrix
    
    Returns:
    
    A
  - rank1
```
public Matrix rank1(Vector x,
                    Vector y)
```
    Description copied from interface: Matrix
    
    A = x*y^T + A. The matrix must be square, and the vectors of the same length
    
    Specified by:
    
    rank1 in interface Matrix
    
    Returns:
    
    A
  - rank1
```
public Matrix rank1(double alpha,
                    Vector x,
                    Vector y)
```
    Description copied from interface: Matrix
    
    A = alpha*x*y^T + A. The matrix must be square, and the vectors of the same length
    
    Specified by:
    
    rank1 in interface Matrix
    
    Returns:
    
    A
  - checkRank1
```
protected void checkRank1(Vector x,
                          Vector y)
```
    Checks that a vector rank1 update is possible for the given vectors
  - rank2
```
public Matrix rank2(Vector x,
                    Vector y)
```
    Description copied from interface: Matrix
    
    A = x*y^T + y*x^T + A. The matrix must be square, and the vectors of the same length
    
    Specified by:
    
    rank2 in interface Matrix
    
    Returns:
    
    A
  - rank2
```
public Matrix rank2(double alpha,
                    Vector x,
                    Vector y)
```
    Description copied from interface: Matrix
    
    A = alpha*x*y^T + alpha*y*x^T + A. The matrix must be square, and the vectors of the same length
    
    Specified by:
    
    rank2 in interface Matrix
    
    Returns:
    
    A
  - checkRank2
```
protected void checkRank2(Vector x,
                          Vector y)
```
    Checks that a vector rank2 update is legal with the given vectors
  - mult
```
public Matrix mult(Matrix B,
                   Matrix C)
```
    Description copied from interface: Matrix
    
    C = A*B
    
    Specified by:
    
    mult in interface Matrix
    
    Parameters:
    
    B - Matrix such that B.numRows() == A.numColumns() and B.numColumns() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numRows() and B.numColumns() == C.numColumns()
    
    Returns:
    
    C
  - mult
```
public Matrix mult(double alpha,
                   Matrix B,
                   Matrix C)
```
    Description copied from interface: Matrix
    
    C = alpha*A*B
    
    Specified by:
    
    mult in interface Matrix
    
    B - Matrix such that B.numRows() == A.numColumns() and B.numColumns() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numRows() and B.numColumns() == C.numColumns()
    
    Returns:
    
    C
  - multAdd
```
public Matrix multAdd(Matrix B,
                      Matrix C)
```
    Description copied from interface: Matrix
    
    C = A*B + C
    
    Specified by:
    
    multAdd in interface Matrix
    
    Parameters:
    
    B - Matrix such that B.numRows() == A.numColumns() and B.numColumns() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numRows() and B.numColumns() == C.numColumns()
    
    Returns:
    
    C
  - multAdd
```
public Matrix multAdd(double alpha,
                      Matrix B,
                      Matrix C)
```
    Description copied from interface: Matrix
    
    C = alpha*A*B + C
    
    Specified by:
    
    multAdd in interface Matrix
    
    B - Matrix such that B.numRows() == A.numColumns() and B.numColumns() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numRows() and B.numColumns() == C.numColumns()
    
    Returns:
    
    C
  - checkMultAdd
```
protected void checkMultAdd(Matrix B,
                            Matrix C)
```
    Checks the arguments to mult and multAdd
  - transAmult
```
public Matrix transAmult(Matrix B,
                         Matrix C)
```
    Description copied from interface: Matrix
    
    C = A^T*B
    
    Specified by:
    
    transAmult in interface Matrix
    
    Parameters:
    
    B - Matrix such that B.numRows() == A.numRows() and B.numColumns() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numColumns() and B.numColumns() == C.numColumns()
    
    Returns:
    
    C
  - transAmult
```
public Matrix transAmult(double alpha,
                         Matrix B,
                         Matrix C)
```
    Description copied from interface: Matrix
    
    C = alpha*A^T*B
    
    Specified by:
    
    transAmult in interface Matrix
    
    B - Matrix such that B.numRows() == A.numRows() and B.numColumns() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numColumns() and B.numColumns() == C.numColumns()
    
    Returns:
    
    C
  - transAmultAdd
```
public Matrix transAmultAdd(Matrix B,
                            Matrix C)
```
    Description copied from interface: Matrix
    
    C = A^T*B + C
    
    Specified by:
    
    transAmultAdd in interface Matrix
    
    Parameters:
    
    B - Matrix such that B.numRows() == A.numRows() and B.numColumns() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numColumns() and B.numColumns() == C.numColumns()
    
    Returns:
    
    C
  - transAmultAdd
```
public Matrix transAmultAdd(double alpha,
                            Matrix B,
                            Matrix C)
```
    Description copied from interface: Matrix
    
    C = alpha*A^T*B + C
    
    Specified by:
    
    transAmultAdd in interface Matrix
    
    B - Matrix such that B.numRows() == A.numRows() and B.numColumns() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numColumns() and B.numColumns() == C.numColumns()
    
    Returns:
    
    C
  - checkTransAmultAdd
```
protected void checkTransAmultAdd(Matrix B,
                                  Matrix C)
```
    Checks the arguments to transAmult and transAmultAdd
  - transBmult
```
public Matrix transBmult(Matrix B,
                         Matrix C)
```
    Description copied from interface: Matrix
    
    C = A*B^T
    
    Specified by:
    
    transBmult in interface Matrix
    
    Parameters:
    
    B - Matrix such that B.numRows() == A.numRows() and B.numColumns() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numColumns() and B.numColumns() == C.numColumns()
    
    Returns:
    
    C
  - transBmult
```
public Matrix transBmult(double alpha,
                         Matrix B,
                         Matrix C)
```
    Description copied from interface: Matrix
    
    C = alpha*A*B^T
    
    Specified by:
    
    transBmult in interface Matrix
    
    B - Matrix such that B.numRows() == A.numRows() and B.numColumns() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numColumns() and B.numColumns() == C.numColumns()
    
    Returns:
    
    C
  - transBmultAdd
```
public Matrix transBmultAdd(Matrix B,
                            Matrix C)
```
    Description copied from interface: Matrix
    
    C = A*B^T + C
    
    Specified by:
    
    transBmultAdd in interface Matrix
    
    Parameters:
    
    B - Matrix such that B.numRows() == A.numRows() and B.numColumns() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numColumns() and B.numColumns() == C.numColumns()
    
    Returns:
    
    C
  - transBmultAdd
```
public Matrix transBmultAdd(double alpha,
                            Matrix B,
                            Matrix C)
```
    Description copied from interface: Matrix
    
    C = alpha*A*B^T + C
    
    Specified by:
    
    transBmultAdd in interface Matrix
    
    B - Matrix such that B.numRows() == A.numRows() and B.numColumns() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numColumns() and B.numColumns() == C.numColumns()
    
    Returns:
    
    C
  - checkTransBmultAdd
```
protected void checkTransBmultAdd(Matrix B,
                                  Matrix C)
```
    Checks the arguments to transBmult and transBmultAdd
  - transABmult
```
public Matrix transABmult(Matrix B,
                          Matrix C)
```
    Description copied from interface: Matrix
    
    C = A^T*B^T
    
    Specified by:
    
    transABmult in interface Matrix
    
    Parameters:
    
    B - Matrix such that B.numColumns() == A.numRows() and B.numRows() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numColumns() and B.numRows() == C.numColumns()
    
    Returns:
    
    C
  - transABmult
```
public Matrix transABmult(double alpha,
                          Matrix B,
                          Matrix C)
```
    Description copied from interface: Matrix
    
    C = alpha*A^T*B^T
    
    Specified by:
    
    transABmult in interface Matrix
    
    B - Matrix such that B.numColumns() == A.numRows() and B.numRows() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numColumns() and B.numRows() == C.numColumns()
    
    Returns:
    
    C
  - transABmultAdd
```
public Matrix transABmultAdd(Matrix B,
                             Matrix C)
```
    Description copied from interface: Matrix
    
    C = A^T*B^T + C
    
    Specified by:
    
    transABmultAdd in interface Matrix
    
    Parameters:
    
    B - Matrix such that B.numColumns() == A.numRows() and B.numRows() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numColumns() and B.numRows() == C.numColumns()
    
    Returns:
    
    C
  - transABmultAdd
```
public Matrix transABmultAdd(double alpha,
                             Matrix B,
                             Matrix C)
```
    Description copied from interface: Matrix
    
    C = alpha*A^T*B^T + C
    
    Specified by:
    
    transABmultAdd in interface Matrix
    
    B - Matrix such that B.numColumns() == A.numRows() and B.numRows() == C.numColumns()
    
    C - Matrix such that C.numRows() == A.numColumns() and B.numRows() == C.numColumns()
    
    Returns:
    
    C
  - checkTransABmultAdd
```
protected void checkTransABmultAdd(Matrix B,
                                   Matrix C)
```
    Checks the arguments to transABmultAdd and transABmultAdd
  - solve
```
public Matrix solve(Matrix B,
                    Matrix X)
```
    Description copied from interface: Matrix
    
    X = A\B. Not all matrices support this operation, those that do not throw UnsupportedOperationException. Note that it is often more efficient to use a matrix decomposition and its associated solver
    
    Specified by:
    
    solve in interface Matrix
    
    Parameters:
    
    B - Matrix with the same number of rows as A, and the same number of columns as X
    
    X - Matrix with a number of rows equal A.numColumns(), and the same number of columns as B
    
    Returns:
    
    X
  - transSolve
```
public Matrix transSolve(Matrix B,
                         Matrix X)
```
    Description copied from interface: Matrix
    
    X = A^T\B. Not all matrices support this operation, those that do not throw UnsupportedOperationException. Note that it is often more efficient to use a matrix decomposition and its associated transpose solver
    
    Specified by:
    
    transSolve in interface Matrix
    
    Parameters:
    
    B - Matrix with a number of rows equal A.numColumns(), and the same number of columns as X
    
    X - Matrix with the same number of rows as A, and the same number of columns as B
    
    Returns:
    
    X
  - checkSolve
```
protected void checkSolve(Matrix B,
                          Matrix X)
```
    Checks that a matrix inversion is legal for the given arguments. This is for the square case, not for least-squares problems
  - rank1
```
public Matrix rank1(Matrix C)
```
    Description copied from interface: Matrix
    
    A = C*C^T + A. The matrices must be square and of the same size
    
    Specified by:
    
    rank1 in interface Matrix
    
    Returns:
    
    A
  - rank1
```
public Matrix rank1(double alpha,
                    Matrix C)
```
    Description copied from interface: Matrix
    
    A = alpha*C*C^T + A. The matrices must be square and of the same size
    
    Specified by:
    
    rank1 in interface Matrix
    
    Returns:
    
    A
  - checkRank1
```
protected void checkRank1(Matrix C)
```
    Checks that a matrix rank1 update is possible for the given matrix
  - transRank1
```
public Matrix transRank1(Matrix C)
```
    Description copied from interface: Matrix
    
    A = C^T*C + A The matrices must be square and of the same size
    
    Specified by:
    
    transRank1 in interface Matrix
    
    Returns:
    
    A
  - transRank1
```
public Matrix transRank1(double alpha,
                         Matrix C)
```
    Description copied from interface: Matrix
    
    A = alpha*C^T*C + A The matrices must be square and of the same size
    
    Specified by:
    
    transRank1 in interface Matrix
    
    Returns:
    
    A
  - checkTransRank1
```
protected void checkTransRank1(Matrix C)
```
    Checks that a transposed rank1 update is leagal with the given argument
  - rank2
```
public Matrix rank2(Matrix B,
                    Matrix C)
```
    Description copied from interface: Matrix
    
    A = B*C^T + C*B^T + A. This matrix must be square
    
    Specified by:
    
    rank2 in interface Matrix
    
    Parameters:
    
    B - Matrix with the same number of rows as A and the same number of columns as C
    
    C - Matrix with the same number of rows as A and the same number of columns as B
    
    Returns:
    
    A
  - rank2
```
public Matrix rank2(double alpha,
                    Matrix B,
                    Matrix C)
```
    Description copied from interface: Matrix
    
    A = alpha*B*C^T + alpha*C*B^T + A. This matrix must be square
    
    Specified by:
    
    rank2 in interface Matrix
    
    B - Matrix with the same number of rows as A and the same number of columns as C
    
    C - Matrix with the same number of rows as A and the same number of columns as B
    
    Returns:
    
    A
  - checkRank2
```
protected void checkRank2(Matrix B,
                          Matrix C)
```
    Checks that a rank2 update is legal for the given arguments
  - transRank2
```
public Matrix transRank2(Matrix B,
                         Matrix C)
```
    Description copied from interface: Matrix
    
    A = B^T*C + C^T*B + A. This matrix must be square
    
    Specified by:
    
    transRank2 in interface Matrix
    
    Parameters:
    
    B - Matrix with the same number of rows as C and the same number of columns as A
    
    C - Matrix with the same number of rows as B and the same number of columns as A
    
    Returns:
    
    A
  - transRank2
```
public Matrix transRank2(double alpha,
                         Matrix B,
                         Matrix C)
```
    Description copied from interface: Matrix
    
    A = alpha*B^T*C + alpha*C^T*B + A. This matrix must be square
    
    Specified by:
    
    transRank2 in interface Matrix
    
    B - Matrix with the same number of rows as C and the same number of columns as A
    
    C - Matrix with the same number of rows as B and the same number of columns as A
    
    Returns:
    
    A
  - checkTransRank2
```
protected void checkTransRank2(Matrix B,
                               Matrix C)
```
    Checks that a transposed rank2 update is leagal with the given arguments
  - scale
```
public Matrix scale(double alpha)
```
    Description copied from interface: Matrix
    
    A = alpha*A
    
    Specified by:
    
    scale in interface Matrix
    
    Returns:
    
    A
  - set
```
public Matrix set(Matrix B)
```
    Description copied from interface: Matrix
    
    A=B. The matrices must be of the same size
    
    Specified by:
    
    set in interface Matrix
    
    Returns:
    
    A
  - set
```
public Matrix set(double alpha,
                  Matrix B)
```
    Description copied from interface: Matrix
    
    A=alpha*B. The matrices must be of the same size
    
    Specified by:
    
    set in interface Matrix
    
    Returns:
    
    A
  - add
```
public Matrix add(Matrix B)
```
    Description copied from interface: Matrix
    
    A = B + A. The matrices must be of the same size
    
    Specified by:
    
    add in interface Matrix
    
    Returns:
    
    A
  - add
```
public Matrix add(double alpha,
                  Matrix B)
```
    Description copied from interface: Matrix
    
    A = alpha*B + A. The matrices must be of the same size
    
    Specified by:
    
    add in interface Matrix
    
    Returns:
    
    A
  - checkSize
```
protected void checkSize(Matrix B)
```
    Checks that the sizes of this matrix and the given conform
  - transpose
```
public Matrix transpose()
```
    Description copied from interface: Matrix
    
    Transposes the matrix in-place. In most cases, the matrix must be square for this to work.
    
    Specified by:
    
    transpose in interface Matrix
    
    Returns:
    
    This matrix
  - checkTranspose
```
protected void checkTranspose()
```
    Checks that the matrix may be transposed
  - transpose
```
public Matrix transpose(Matrix B)
```
    Description copied from interface: Matrix
    
    Sets the tranpose of this matrix into B. Matrix dimensions must be compatible
    
    Specified by:
    
    transpose in interface Matrix
    
    Parameters:
    
    B - Matrix with as many rows as this matrix has columns, and as many columns as this matrix has rows
    
    Returns:
    
    The matrix B=A^T
  - checkTranspose
```
protected void checkTranspose(Matrix B)
```
    Checks that this matrix can be transposed into the given matrix
  - norm
```
public double norm(Matrix.Norm type)
```
    Description copied from interface: Matrix
    
    Computes the given norm of the matrix
    
    Specified by:
    
    norm in interface Matrix
    
    Parameters:
    
    type - The type of norm to compute
  - norm1
```
protected double norm1()
```
    Computes the 1 norm
  - normF
```
protected double normF()
```
    Computes the Frobenius norm. This implementation is overflow resistant
  - normInf
```
protected double normInf()
```
    Computes the infinity norm
  - max
```
protected double max()
```
    Returns the largest absolute value
  - max
```
protected double max(double[] x)
```
    Returns the largest element of the passed array
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - iterator
```
public java.util.Iterator<MatrixEntry> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<MatrixEntry>

Modifier and Type	Field	Description
`protected int`	`numColumns`	Number of columns
`protected int`	`numRows`	Number of rows

Class AbstractMatrix

Nested Class Summary

Nested classes/interfaces inherited from interface no.uib.cipr.matrix.Matrix

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Field Detail

numRows

numColumns

Constructor Detail

AbstractMatrix

AbstractMatrix

Method Detail

numRows

numColumns

isSquare

set

add

get

check

copy

zero

mult

mult

multAdd

multAdd

checkMultAdd

transMult

transMult

transMultAdd

transMultAdd

checkTransMultAdd

solve

transSolve

checkSolve

rank1

rank1

rank1

rank1

checkRank1

rank2

rank2

checkRank2

mult

mult

multAdd

multAdd

checkMultAdd

transAmult

transAmult

transAmultAdd

transAmultAdd

checkTransAmultAdd

transBmult

transBmult

transBmultAdd

transBmultAdd

checkTransBmultAdd

transABmult

transABmult

transABmultAdd

transABmultAdd

checkTransABmultAdd

solve

transSolve

checkSolve

rank1

rank1

checkRank1

transRank1

transRank1

checkTransRank1

rank2

rank2

checkRank2

transRank2

transRank2

checkTransRank2