# `linalg.decomp_qr`¶

QR decomposition functions.

## Module Contents¶

### Functions¶

 `safecall`(f,name,*args,**kwargs) Call a LAPACK routine, determining lwork automatically and handling `qr`(a,overwrite_a=False,lwork=None,mode=”full”,pivoting=False,check_finite=True) Compute QR decomposition of a matrix. `qr_multiply`(a,c,mode=”right”,pivoting=False,conjugate=False,overwrite_a=False,overwrite_c=False) Calculate the QR decomposition and multiply Q with a matrix. `rq`(a,overwrite_a=False,lwork=None,mode=”full”,check_finite=True) Compute RQ decomposition of a matrix.
`safecall`(f, name, *args, **kwargs)

Call a LAPACK routine, determining lwork automatically and handling error return values

`qr`(a, overwrite_a=False, lwork=None, mode="full", pivoting=False, check_finite=True)

Compute QR decomposition of a matrix.

Calculate the decomposition `A = Q R` where Q is unitary/orthogonal and R upper triangular.

a : (M, N) array_like
Matrix to be decomposed
overwrite_a : bool, optional
Whether data in a is overwritten (may improve performance)
lwork : int, optional
Work array size, lwork >= a.shape[1]. If None or -1, an optimal size is computed.
mode : {‘full’, ‘r’, ‘economic’, ‘raw’}, optional
Determines what information is to be returned: either both Q and R (‘full’, default), only R (‘r’) or both Q and R but computed in economy-size (‘economic’, see Notes). The final option ‘raw’ (added in Scipy 0.11) makes the function return two matrices (Q, TAU) in the internal format used by LAPACK.
pivoting : bool, optional
Whether or not factorization should include pivoting for rank-revealing qr decomposition. If pivoting, compute the decomposition `A P = Q R` as above, but where P is chosen such that the diagonal of R is non-increasing.
check_finite : bool, optional
Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs.
Q : float or complex ndarray
Of shape (M, M), or (M, K) for `mode='economic'`. Not returned if `mode='r'`.
R : float or complex ndarray
Of shape (M, N), or (K, N) for `mode='economic'`. `K = min(M, N)`.
P : int ndarray
Of shape (N,) for `pivoting=True`. Not returned if `pivoting=False`.
LinAlgError
Raised if decomposition fails

This is an interface to the LAPACK routines dgeqrf, zgeqrf, dorgqr, zungqr, dgeqp3, and zgeqp3.

If `mode=economic`, the shapes of Q and R are (M, K) and (K, N) instead of (M,M) and (M,N), with `K=min(M,N)`.

```>>> from scipy import random, linalg, dot, diag, all, allclose
>>> a = random.randn(9, 6)
```
```>>> q, r = linalg.qr(a)
>>> allclose(a, np.dot(q, r))
True
>>> q.shape, r.shape
((9, 9), (9, 6))
```
```>>> r2 = linalg.qr(a, mode='r')
>>> allclose(r, r2)
True
```
```>>> q3, r3 = linalg.qr(a, mode='economic')
>>> q3.shape, r3.shape
((9, 6), (6, 6))
```
```>>> q4, r4, p4 = linalg.qr(a, pivoting=True)
>>> d = abs(diag(r4))
>>> all(d[1:] <= d[:-1])
True
>>> allclose(a[:, p4], dot(q4, r4))
True
>>> q4.shape, r4.shape, p4.shape
((9, 9), (9, 6), (6,))
```
```>>> q5, r5, p5 = linalg.qr(a, mode='economic', pivoting=True)
>>> q5.shape, r5.shape, p5.shape
((9, 6), (6, 6), (6,))
```
`qr_multiply`(a, c, mode="right", pivoting=False, conjugate=False, overwrite_a=False, overwrite_c=False)

Calculate the QR decomposition and multiply Q with a matrix.

Calculate the decomposition `A = Q R` where Q is unitary/orthogonal and R upper triangular. Multiply Q with a vector or a matrix c.

a : array_like, shape (M, N)
Matrix to be decomposed
c : array_like, one- or two-dimensional
calculate the product of c and q, depending on the mode:
mode : {‘left’, ‘right’}, optional
`dot(Q, c)` is returned if mode is ‘left’, `dot(c, Q)` is returned if mode is ‘right’. The shape of c must be appropriate for the matrix multiplications, if mode is ‘left’, `min(a.shape) == c.shape[0]`, if mode is ‘right’, `a.shape[0] == c.shape[1]`.
pivoting : bool, optional
Whether or not factorization should include pivoting for rank-revealing qr decomposition, see the documentation of qr.
conjugate : bool, optional
Whether Q should be complex-conjugated. This might be faster than explicit conjugation.
overwrite_a : bool, optional
Whether data in a is overwritten (may improve performance)
overwrite_c : bool, optional
Whether data in c is overwritten (may improve performance). If this is used, c must be big enough to keep the result, i.e. c.shape[0] = a.shape[0] if mode is ‘left’.
CQ : float or complex ndarray
the product of Q and c, as defined in mode
R : float or complex ndarray
Of shape (K, N), `K = min(M, N)`.
P : ndarray of ints
Of shape (N,) for `pivoting=True`. Not returned if `pivoting=False`.
LinAlgError
Raised if decomposition fails

This is an interface to the LAPACK routines dgeqrf, zgeqrf, dormqr, zunmqr, dgeqp3, and zgeqp3.

New in version 0.11.0.

`rq`(a, overwrite_a=False, lwork=None, mode="full", check_finite=True)

Compute RQ decomposition of a matrix.

Calculate the decomposition `A = R Q` where Q is unitary/orthogonal and R upper triangular.

a : (M, N) array_like
Matrix to be decomposed
overwrite_a : bool, optional
Whether data in a is overwritten (may improve performance)
lwork : int, optional
Work array size, lwork >= a.shape[1]. If None or -1, an optimal size is computed.
mode : {‘full’, ‘r’, ‘economic’}, optional
Determines what information is to be returned: either both Q and R (‘full’, default), only R (‘r’) or both Q and R but computed in economy-size (‘economic’, see Notes).
check_finite : bool, optional
Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs.
R : float or complex ndarray
Of shape (M, N) or (M, K) for `mode='economic'`. `K = min(M, N)`.
Q : float or complex ndarray
Of shape (N, N) or (K, N) for `mode='economic'`. Not returned if `mode='r'`.
LinAlgError
If decomposition fails.

This is an interface to the LAPACK routines sgerqf, dgerqf, cgerqf, zgerqf, sorgrq, dorgrq, cungrq and zungrq.

If `mode=economic`, the shapes of Q and R are (K, N) and (M, K) instead of (N,N) and (M,N), with `K=min(M,N)`.

```>>> from scipy import linalg
>>> from numpy import random, dot, allclose
>>> a = random.randn(6, 9)
>>> r, q = linalg.rq(a)
>>> allclose(a, dot(r, q))
True
>>> r.shape, q.shape
((6, 9), (9, 9))
>>> r2 = linalg.rq(a, mode='r')
>>> allclose(r, r2)
True
>>> r3, q3 = linalg.rq(a, mode='economic')
>>> r3.shape, q3.shape
((6, 6), (6, 9))
```