naginterfaces.library.lapackeig.dgeqrt

naginterfaces.library.lapackeig.dgeqrt(nb, a)

dgeqrt recursively computes, with explicit blocking, the $QR$ factorization of a real $m\times n$ matrix.

For full information please refer to the NAG Library document for f08ab

https://support.nag.com/numeric/nl/nagdoc_30.3/flhtml/f08/f08abf.html

Parameters

nbint

The explicitly chosen block size to be used in computing the $QR$ factorization. See Further Comments for details.

afloat, array-like, shape $(m,n)$

The $m\times n$ matrix $A$.

Returns

afloat, ndarray, shape $(m,n)$

If $m\ge n$, the elements below the diagonal are overwritten by details of the orthogonal matrix $Q$ and the upper triangle is overwritten by the corresponding elements of the $n\times n$ upper triangular matrix $R$.

If $m<n$, the strictly lower triangular part is overwritten by details of the orthogonal matrix $Q$ and the remaining elements are overwritten by the corresponding elements of the $m\times n$ upper trapezoidal matrix $R$.

tfloat, ndarray, shape $(nb,min(m,n))$

Further details of the orthogonal matrix $Q$. The number of blocks is $b=\lceil \frac{k}{nb}\rceil$, where $k=min(m,n)$ and each block is of order $nb$ except for the last block, which is of order $k-(b-1)\times nb$. For each of the blocks, an upper triangular block reflector factor is computed: $T_1,T_2,\dots ,T_b$. These are stored in the $nb\times n$ matrix $T$ as $T=[T_1|T_2|\cdots |T_b]$.

Raises

NagValueError

(errno $-1$)

On entry, error in parameter $\text{m}$.

Constraint: $m\ge 0$.

(errno $-2$)

On entry, error in parameter $\text{n}$.

Constraint: $n\ge 0$.

(errno $-3$)

On entry, error in parameter $nb$.

Constraint: $1\le nb\le min(m,n)$.

Notes

dgeqrt forms the $QR$ factorization of an arbitrary rectangular real $m\times n$ matrix. No pivoting is performed.

It differs from dgeqrf() in that it: requires an explicit block size; stores reflector factors that are upper triangular matrices of the chosen block size (rather than scalars); and recursively computes the $QR$ factorization based on the algorithm of Elmroth and Gustavson (2000).

If $m\ge n$, the factorization is given by:

$$\begin{array}{c}A=Q\left(\begin{array}{c}R\\ 0\end{array}\right)\text{,}\end{array}$$

where $R$ is an $n\times n$ upper triangular matrix and $Q$ is an $m\times m$ orthogonal matrix. It is sometimes more convenient to write the factorization as

$$\begin{array}{c}A=\left(\begin{array}{cc}{Q}_1& Q_2\end{array}\right)\left(\begin{array}{c}R\\ 0\end{array}\right)\text{,}\end{array}$$

which reduces to

$$A=Q_{1}R\text{,}$$

where $Q_1$ consists of the first $n$ columns of $Q$, and $Q_2$ the remaining $m-n$ columns.

If $m<n$, $R$ is upper trapezoidal, and the factorization can be written

$$A=Q\left(\begin{array}{cc}{R}_1& R_2\end{array}\right)\text{,}$$

where $R_1$ is upper triangular and $R_2$ is rectangular.

The matrix $Q$ is not formed explicitly but is represented as a product of $min(m,n)$ elementary reflectors (see the F08 Introduction for details). Functions are provided to work with $Q$ in this representation (see Further Comments).

Note also that for any $k<n$, the information returned represents a $QR$ factorization of the first $k$ columns of the original matrix $A$.

References

Elmroth, E and Gustavson, F, 2000, Applying Recursion to Serial and Parallel $QR$ Factorization Leads to Better Performance, IBM Journal of Research and Development. (Volume 44) (4), 605–624

Golub, G H and Van Loan, C F, 2012, Matrix Computations, (4th Edition), Johns Hopkins University Press, Baltimore