org.ejml.dense.row.decomposition.qr

## Class QRDecompositionHouseholderColumn_DDRM

• java.lang.Object
• org.ejml.dense.row.decomposition.qr.QRDecompositionHouseholderColumn_DDRM
• ### Field Summary

Fields
Modifier and Type Field and Description
`protected double[][]` `dataQR`
Where the Q and R matrices are stored.
`protected boolean` `error`
`protected double` `gamma`
`protected double[]` `gammas`
`protected int` `minLength`
`protected int` `numCols`
`protected int` `numRows`
`protected double` `tau`
`protected double[]` `v`
• ### Constructor Summary

Constructors
Constructor and Description
`QRDecompositionHouseholderColumn_DDRM()`
• ### Method Summary

All Methods
Modifier and Type Method and Description
`protected void` `convertToColumnMajor(DMatrixRMaj A)`
Converts the standard row-major matrix into a column-major vector that is advantageous for this problem.
`boolean` `decompose(DMatrixRMaj A)`
To decompose the matrix 'A' it must have full rank.
`double[]` `getGammas()`
`DMatrixRMaj` ```getQ(DMatrixRMaj Q, boolean compact)```
Computes the Q matrix from the imformation stored in the QR matrix.
`double[][]` `getQR()`
Returns the combined QR matrix in a 2D array format that is column major.
`DMatrixRMaj` ```getR(DMatrixRMaj R, boolean compact)```
Returns an upper triangular matrix which is the R in the QR decomposition.
`protected void` `householder(int j)`
Computes the householder vector "u" for the first column of submatrix j.
`boolean` `inputModified()`
Is the input matrix to `DecompositionInterface.decompose(org.ejml.data.Matrix)` is modified during the decomposition process.
`void` ```setExpectedMaxSize(int numRows, int numCols)```
`protected void` `updateA(int w)`
Takes the results from the householder computation and updates the 'A' matrix.

A = (I - γ*u*uT)A
• ### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• ### Field Detail

• #### dataQR

`protected double[][] dataQR`
Where the Q and R matrices are stored. R is stored in the upper triangular portion and Q on the lower bit. Lower columns are where u is stored. Q_k = (I - gamma_k*u_k*u_k^T).
• #### v

`protected double[] v`
• #### numCols

`protected int numCols`
• #### numRows

`protected int numRows`
• #### minLength

`protected int minLength`
• #### gammas

`protected double[] gammas`
• #### gamma

`protected double gamma`
• #### tau

`protected double tau`
• #### error

`protected boolean error`
• ### Constructor Detail

• #### QRDecompositionHouseholderColumn_DDRM

`public QRDecompositionHouseholderColumn_DDRM()`
• ### Method Detail

• #### setExpectedMaxSize

```public void setExpectedMaxSize(int numRows,
int numCols)```
• #### getQR

`public double[][] getQR()`
Returns the combined QR matrix in a 2D array format that is column major.
Returns:
The QR matrix in a 2D matrix column major format. [ column ][ row ]
• #### getQ

```public DMatrixRMaj getQ(DMatrixRMaj Q,
boolean compact)```
Computes the Q matrix from the imformation stored in the QR matrix. This operation requires about 4(m2n-mn2+n3/3) flops.
Specified by:
`getQ` in interface `QRDecomposition<DMatrixRMaj>`
Parameters:
`Q` - The orthogonal Q matrix.
`compact` - If true an m by n matrix is created, otherwise n by n.
Returns:
The Q matrix.
• #### getR

```public DMatrixRMaj getR(DMatrixRMaj R,
boolean compact)```
Returns an upper triangular matrix which is the R in the QR decomposition. If compact then the input expected to be size = [min(rows,cols) , numCols] otherwise size = [numRows,numCols].
Specified by:
`getR` in interface `QRDecomposition<DMatrixRMaj>`
Parameters:
`R` - Storage for upper triangular matrix.
`compact` - If true then a compact matrix is expected.
Returns:
The R matrix.
• #### decompose

`public boolean decompose(DMatrixRMaj A)`

To decompose the matrix 'A' it must have full rank. 'A' is a 'm' by 'n' matrix. It requires about 2n*m2-2m2/3 flops.

The matrix provided here can be of different dimension than the one specified in the constructor. It just has to be smaller than or equal to it.

Specified by:
`decompose` in interface `DecompositionInterface<DMatrixRMaj>`
Parameters:
`A` - The matrix which is being decomposed. Modification is implementation dependent.
Returns:
Returns if it was able to decompose the matrix.
• #### inputModified

`public boolean inputModified()`
Description copied from interface: `DecompositionInterface`
Is the input matrix to `DecompositionInterface.decompose(org.ejml.data.Matrix)` is modified during the decomposition process.
Specified by:
`inputModified` in interface `DecompositionInterface<DMatrixRMaj>`
Returns:
true if the input matrix to decompose() is modified.
• #### convertToColumnMajor

`protected void convertToColumnMajor(DMatrixRMaj A)`
Converts the standard row-major matrix into a column-major vector that is advantageous for this problem.
Parameters:
`A` - original matrix that is to be decomposed.
• #### householder

`protected void householder(int j)`

Computes the householder vector "u" for the first column of submatrix j. Note this is a specialized householder for this problem. There is some protection against overfloaw and underflow.

Q = I - γuuT

This function finds the values of 'u' and 'γ'.

Parameters:
`j` - Which submatrix to work off of.
• #### updateA

`protected void updateA(int w)`

Takes the results from the householder computation and updates the 'A' matrix.

A = (I - γ*u*uT)A

Parameters:
`w` - The submatrix.
• #### getGammas

`public double[] getGammas()`