QR and RQ factorizations: blocked, tall-skinny, pivoted and triangular-pentagonal variants. More...

Functions/Subroutines
pure recursive subroutine, public	la_slaorhr_col_getrfnp2 (m, n, a, lda, d, info)
	SLAORHR_COL_GETRFNP2: computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine SORHR_COL. In SORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 \| B12 ] where B11 is n1 by n1, B = [ --—\|--— ] B21 is (m-n1) by n1, [ B21 \| B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. SLAORHR_COL_GETRFNP2 is called to factorize a block by the blocked routine SLAORHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, SLAORHR_COL_GETRFNP2 is self-sufficient and can be used without SLAORHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

pure recursive subroutine, public	la_dlaorhr_col_getrfnp2 (m, n, a, lda, d, info)
	DLAORHR_COL_GETRFNP2: computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine DORHR_COL. In DORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 \| B12 ] where B11 is n1 by n1, B = [ --—\|--— ] B21 is (m-n1) by n1, [ B21 \| B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. DLAORHR_COL_GETRFNP2 is called to factorize a block by the blocked routine DLAORHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, DLAORHR_COL_GETRFNP2 is self-sufficient and can be used without DLAORHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

pure recursive subroutine, public	la_qlaorhr_col_getrfnp2 (m, n, a, lda, d, info)
	QLAORHR_COL_GETRFNP2: computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine QORHR_COL. In QORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 \| B12 ] where B11 is n1 by n1, B = [ --—\|--— ] B21 is (m-n1) by n1, [ B21 \| B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. QLAORHR_COL_GETRFNP2 is called to factorize a block by the blocked routine QLAORHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, QLAORHR_COL_GETRFNP2 is self-sufficient and can be used without QLAORHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

pure subroutine, public	la_slarfb_gett (ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)
	SLARFB_GETT: applies a real Householder block reflector H from the left to a real (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.

pure subroutine, public	la_dlarfb_gett (ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)
	DLARFB_GETT: applies a real Householder block reflector H from the left to a real (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.

pure subroutine, public	la_qlarfb_gett (ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)
	QLARFB_GETT: applies a real Householder block reflector H from the left to a real (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.

pure subroutine, public	la_sorg2r (m, n, k, a, lda, tau, work, info)
	SORG2R: generates an m by n real matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by SGEQRF.

pure subroutine, public	la_dorg2r (m, n, k, a, lda, tau, work, info)
	DORG2R: generates an m by n real matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by DGEQRF.

pure subroutine, public	la_qorg2r (m, n, k, a, lda, tau, work, info)
	QORG2R: generates an m by n real matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by QGEQRF.

pure subroutine, public	la_sorgqr (m, n, k, a, lda, tau, work, lwork, info)
	SORGQR: generates an M-by-N real matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by SGEQRF.

pure subroutine, public	la_dorgqr (m, n, k, a, lda, tau, work, lwork, info)
	DORGQR: generates an M-by-N real matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by DGEQRF.

pure subroutine, public	la_qorgqr (m, n, k, a, lda, tau, work, lwork, info)
	QORGQR: generates an M-by-N real matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by QGEQRF.

pure subroutine, public	la_sorgr2 (m, n, k, a, lda, tau, work, info)
	SORGR2: generates an m by n real matrix Q with orthonormal rows, which is defined as the last m rows of a product of k elementary reflectors of order n Q = H(1) H(2) . . . H(k) as returned by SGERQF.

pure subroutine, public	la_dorgr2 (m, n, k, a, lda, tau, work, info)
	DORGR2: generates an m by n real matrix Q with orthonormal rows, which is defined as the last m rows of a product of k elementary reflectors of order n Q = H(1) H(2) . . . H(k) as returned by DGERQF.

pure subroutine, public	la_qorgr2 (m, n, k, a, lda, tau, work, info)
	QORGR2: generates an m by n real matrix Q with orthonormal rows, which is defined as the last m rows of a product of k elementary reflectors of order n Q = H(1) H(2) . . . H(k) as returned by QGERQF.

pure subroutine, public	la_sorgrq (m, n, k, a, lda, tau, work, lwork, info)
	SORGRQ: generates an M-by-N real matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1) H(2) . . . H(k) as returned by SGERQF.

pure subroutine, public	la_dorgrq (m, n, k, a, lda, tau, work, lwork, info)
	DORGRQ: generates an M-by-N real matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1) H(2) . . . H(k) as returned by DGERQF.

pure subroutine, public	la_qorgrq (m, n, k, a, lda, tau, work, lwork, info)
	QORGRQ: generates an M-by-N real matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1) H(2) . . . H(k) as returned by QGERQF.

pure subroutine, public	la_sorgtsqr_row (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	SORGTSQR_ROW: generates an M-by-N real matrix Q_out with orthonormal columns from the output of SLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by SLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of SLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine SLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which SLATSQR generates the output blocks.

pure subroutine, public	la_dorgtsqr_row (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	DORGTSQR_ROW: generates an M-by-N real matrix Q_out with orthonormal columns from the output of DLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by DLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of DLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine DLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which DLATSQR generates the output blocks.

pure subroutine, public	la_qorgtsqr_row (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	QORGTSQR_ROW: generates an M-by-N real matrix Q_out with orthonormal columns from the output of QLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by QLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of QLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine QLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which QLATSQR generates the output blocks.

pure subroutine, public	la_sorm2r (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	SORM2R: overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*T C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by SGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_dorm2r (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	DORM2R: overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*T C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_qorm2r (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	QORM2R: overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*T C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by QGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_sormqr (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	SORMQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by SGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_dormqr (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	DORMQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_qormqr (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	QORMQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by QGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_sormr2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	SORMR2: overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*T C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by SGERQF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_dormr2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	DORMR2: overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*T C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGERQF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_qormr2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	QORMR2: overwrites the general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*T C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'T', where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by QGERQF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_sormrq (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	SORMRQ: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by SGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_dormrq (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	DORMRQ: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by DGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_qormrq (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	QORMRQ: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by QGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_stprfb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)
	STPRFB: applies a real "triangular-pentagonal" block reflector H or its conjugate transpose H^H to a real matrix C, which is composed of two blocks A and B, either from the left or right.

pure subroutine, public	la_dtprfb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)
	DTPRFB: applies a real "triangular-pentagonal" block reflector H or its transpose H**T to a real matrix C, which is composed of two blocks A and B, either from the left or right.

pure subroutine, public	la_qtprfb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)
	QTPRFB: applies a real "triangular-pentagonal" block reflector H or its transpose H**T to a real matrix C, which is composed of two blocks A and B, either from the left or right.

pure subroutine, public	la_sgemqrt (side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)
	SGEMQRT: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'T': QT C C QT where Q is a real orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**T generated using the compact WY representation as returned by SGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_dgemqrt (side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)
	DGEMQRT: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'T': QT C C QT where Q is a real orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**T generated using the compact WY representation as returned by DGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_qgemqrt (side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)
	QGEMQRT: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'T': QT C C QT where Q is a real orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**T generated using the compact WY representation as returned by QGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_slaorhr_col_getrfnp (m, n, a, lda, d, info)
	SLAORHR_COL_GETRFNP: computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine SORHR_COL. In SORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine SLAORHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

pure subroutine, public	la_dlaorhr_col_getrfnp (m, n, a, lda, d, info)
	DLAORHR_COL_GETRFNP: computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine DORHR_COL. In DORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine DLAORHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

pure subroutine, public	la_qlaorhr_col_getrfnp (m, n, a, lda, d, info)
	QLAORHR_COL_GETRFNP: computes the modified LU factorization without pivoting of a real general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine QORHR_COL. In QORHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine QLAORHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

pure subroutine, public	la_sorhr_col (m, n, nb, a, lda, t, ldt, d, info)
	SORHR_COL: takes an M-by-N real matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as SGEQRT).

pure subroutine, public	la_dorhr_col (m, n, nb, a, lda, t, ldt, d, info)
	DORHR_COL: takes an M-by-N real matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as DGEQRT).

pure subroutine, public	la_qorhr_col (m, n, nb, a, lda, t, ldt, d, info)
	QORHR_COL: takes an M-by-N real matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as QGEQRT).

pure subroutine, public	la_stpmqrt (side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)
	STPMQRT: applies a real orthogonal matrix Q obtained from a "triangular-pentagonal" real block reflector H to a general real matrix C, which consists of two blocks A and B.

pure subroutine, public	la_dtpmqrt (side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)
	DTPMQRT: applies a real orthogonal matrix Q obtained from a "triangular-pentagonal" real block reflector H to a general real matrix C, which consists of two blocks A and B.

pure subroutine, public	la_qtpmqrt (side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)
	QTPMQRT: applies a real orthogonal matrix Q obtained from a "triangular-pentagonal" real block reflector H to a general real matrix C, which consists of two blocks A and B.

pure subroutine, public	la_stpqrt2 (m, n, l, a, lda, b, ldb, t, ldt, info)
	STPQRT2: computes a QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_dtpqrt2 (m, n, l, a, lda, b, ldb, t, ldt, info)
	DTPQRT2: computes a QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_qtpqrt2 (m, n, l, a, lda, b, ldb, t, ldt, info)
	QTPQRT2: computes a QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_sgeqr2 (m, n, a, lda, tau, work, info)
	SGEQR2: computes a QR factorization of a real m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix; 0 is a (m-n)-by-n zero matrix, if m > n.

pure subroutine, public	la_dgeqr2 (m, n, a, lda, tau, work, info)
	DGEQR2: computes a QR factorization of a real m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix; 0 is a (m-n)-by-n zero matrix, if m > n.

pure subroutine, public	la_qgeqr2 (m, n, a, lda, tau, work, info)
	QGEQR2: computes a QR factorization of a real m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix; 0 is a (m-n)-by-n zero matrix, if m > n.

subroutine, public	la_sgeqr2p (m, n, a, lda, tau, work, info)
	SGEQR2P: computes a QR factorization of a real m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.

subroutine, public	la_dgeqr2p (m, n, a, lda, tau, work, info)
	DGEQR2P: computes a QR factorization of a real m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.

subroutine, public	la_qgeqr2p (m, n, a, lda, tau, work, info)
	QGEQR2P: computes a QR factorization of a real m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.

pure subroutine, public	la_sgeqrf (m, n, a, lda, tau, work, lwork, info)
	SGEQRF: computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

pure subroutine, public	la_dgeqrf (m, n, a, lda, tau, work, lwork, info)
	DGEQRF: computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

pure subroutine, public	la_qgeqrf (m, n, a, lda, tau, work, lwork, info)
	QGEQRF: computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

subroutine, public	la_sgeqrfp (m, n, a, lda, tau, work, lwork, info)
	SGEQR2P computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.

subroutine, public	la_dgeqrfp (m, n, a, lda, tau, work, lwork, info)
	DGEQR2P computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.

subroutine, public	la_qgeqrfp (m, n, a, lda, tau, work, lwork, info)
	QGEQR2P computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.

pure subroutine, public	la_sgeqrt2 (m, n, a, lda, t, ldt, info)
	SGEQRT2: computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q.

pure subroutine, public	la_dgeqrt2 (m, n, a, lda, t, ldt, info)
	DGEQRT2: computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q.

pure subroutine, public	la_qgeqrt2 (m, n, a, lda, t, ldt, info)
	QGEQRT2: computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q.

pure recursive subroutine, public	la_sgeqrt3 (m, n, a, lda, t, ldt, info)
	SGEQRT3: recursively computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

pure recursive subroutine, public	la_dgeqrt3 (m, n, a, lda, t, ldt, info)
	DGEQRT3: recursively computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

pure recursive subroutine, public	la_qgeqrt3 (m, n, a, lda, t, ldt, info)
	QGEQRT3: recursively computes a QR factorization of a real M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

pure subroutine, public	la_sgerq2 (m, n, a, lda, tau, work, info)
	SGERQ2: computes an RQ factorization of a real m by n matrix A: A = R * Q.

pure subroutine, public	la_dgerq2 (m, n, a, lda, tau, work, info)
	DGERQ2: computes an RQ factorization of a real m by n matrix A: A = R * Q.

pure subroutine, public	la_qgerq2 (m, n, a, lda, tau, work, info)
	QGERQ2: computes an RQ factorization of a real m by n matrix A: A = R * Q.

pure subroutine, public	la_sgerqf (m, n, a, lda, tau, work, lwork, info)
	SGERQF: computes an RQ factorization of a real M-by-N matrix A: A = R * Q.

pure subroutine, public	la_dgerqf (m, n, a, lda, tau, work, lwork, info)
	DGERQF: computes an RQ factorization of a real M-by-N matrix A: A = R * Q.

pure subroutine, public	la_qgerqf (m, n, a, lda, tau, work, lwork, info)
	QGERQF: computes an RQ factorization of a real M-by-N matrix A: A = R * Q.

pure subroutine, public	la_sggqrf (n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)
	SGGQRF: computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZT(inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.

pure subroutine, public	la_dggqrf (n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)
	DGGQRF: computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZT(inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.

pure subroutine, public	la_qggqrf (n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)
	QGGQRF: computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZT(inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.

pure subroutine, public	la_sggrqf (m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)
	SGGRQF: computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZT where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.

pure subroutine, public	la_dggrqf (m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)
	DGGRQF: computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZT where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.

pure subroutine, public	la_qggrqf (m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)
	QGGRQF: computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N orthogonal matrix, Z is a P-by-P orthogonal matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZT where inv(B) denotes the inverse of the matrix B, and Z*T denotes the transpose of the matrix Z.

pure subroutine, public	la_slamtsqr (side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)
	SLAMTSQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (SLATSQR)

pure subroutine, public	la_dlamtsqr (side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)
	DLAMTSQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (DLATSQR)

pure subroutine, public	la_qlamtsqr (side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)
	QLAMTSQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (QLATSQR)

pure subroutine, public	la_slaqp2 (m, n, offset, a, lda, jpvt, tau, vn1, vn2, work)
	SLAQP2: computes a QR factorization with column pivoting of the block A(OFFSET+1:M,1:N). The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_dlaqp2 (m, n, offset, a, lda, jpvt, tau, vn1, vn2, work)
	DLAQP2: computes a QR factorization with column pivoting of the block A(OFFSET+1:M,1:N). The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_qlaqp2 (m, n, offset, a, lda, jpvt, tau, vn1, vn2, work)
	QLAQP2: computes a QR factorization with column pivoting of the block A(OFFSET+1:M,1:N). The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_slaqps (m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)
	SLAQPS: computes a step of QR factorization with column pivoting of a real M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_dlaqps (m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)
	DLAQPS: computes a step of QR factorization with column pivoting of a real M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_qlaqps (m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)
	QLAQPS: computes a step of QR factorization with column pivoting of a real M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_sorgtsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	SORGTSQR: generates an M-by-N real matrix Q_out with orthonormal columns, which are the first N columns of a product of real orthogonal matrices of order M which are returned by SLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for SLATSQR.

pure subroutine, public	la_dorgtsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	DORGTSQR: generates an M-by-N real matrix Q_out with orthonormal columns, which are the first N columns of a product of real orthogonal matrices of order M which are returned by DLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for DLATSQR.

pure subroutine, public	la_qorgtsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	QORGTSQR: generates an M-by-N real matrix Q_out with orthonormal columns, which are the first N columns of a product of real orthogonal matrices of order M which are returned by QLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for QLATSQR.

pure subroutine, public	la_stpqrt (m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)
	STPQRT: computes a blocked QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_dtpqrt (m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)
	DTPQRT: computes a blocked QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_qtpqrt (m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)
	QTPQRT: computes a blocked QR factorization of a real "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_sgemqr (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)
	SGEMQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (SGEQR)

pure subroutine, public	la_dgemqr (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)
	DGEMQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (DGEQR)

pure subroutine, public	la_qgemqr (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)
	QGEMQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*T C C * Q**T where Q is a real orthogonal matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (QGEQR)

pure subroutine, public	la_sgeqp3 (m, n, a, lda, jpvt, tau, work, lwork, info)
	SGEQP3: computes a QR factorization with column pivoting of a matrix A: AP = QR using Level 3 BLAS.

pure subroutine, public	la_dgeqp3 (m, n, a, lda, jpvt, tau, work, lwork, info)
	DGEQP3: computes a QR factorization with column pivoting of a matrix A: AP = QR using Level 3 BLAS.

pure subroutine, public	la_qgeqp3 (m, n, a, lda, jpvt, tau, work, lwork, info)
	QGEQP3: computes a QR factorization with column pivoting of a matrix A: AP = QR using Level 3 BLAS.

pure subroutine, public	la_sgeqrt (m, n, nb, a, lda, t, ldt, work, info)
	SGEQRT: computes a blocked QR factorization of a real M-by-N matrix A using the compact WY representation of Q.

pure subroutine, public	la_dgeqrt (m, n, nb, a, lda, t, ldt, work, info)
	DGEQRT: computes a blocked QR factorization of a real M-by-N matrix A using the compact WY representation of Q.

pure subroutine, public	la_qgeqrt (m, n, nb, a, lda, t, ldt, work, info)
	QGEQRT: computes a blocked QR factorization of a real M-by-N matrix A using the compact WY representation of Q.

pure subroutine, public	la_slatsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	SLATSQR: computes a blocked Tall-Skinny QR factorization of a real M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.

pure subroutine, public	la_dlatsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	DLATSQR: computes a blocked Tall-Skinny QR factorization of a real M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.

pure subroutine, public	la_qlatsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	QLATSQR: computes a blocked Tall-Skinny QR factorization of a real M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.

pure subroutine, public	la_sgeqr (m, n, a, lda, t, tsize, work, lwork, info)
	SGEQR: computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

pure subroutine, public	la_dgeqr (m, n, a, lda, t, tsize, work, lwork, info)
	DGEQR: computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

pure subroutine, public	la_qgeqr (m, n, a, lda, t, tsize, work, lwork, info)
	QGEQR: computes a QR factorization of a real M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

pure subroutine, public	la_sgetsqrhrt (m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)
	SGETSQRHRT: computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in SGEQRT (Q is in blocked compact WY-representation). See the documentation of SGEQRT for more details on the format.

pure subroutine, public	la_dgetsqrhrt (m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)
	DGETSQRHRT: computes a NB2-sized column blocked QR-factorization of a real M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in DGEQRT (Q is in blocked compact WY-representation). See the documentation of DGEQRT for more details on the format.

pure subroutine, public	la_qgetsqrhrt (m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)
	QGETSQRHRT: computes a NB2-sized column blocked QR-factorization of a real M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in QGEQRT (Q is in blocked compact WY-representation). See the documentation of QGEQRT for more details on the format.

pure subroutine, public	la_clarfb_gett (ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)
	CLARFB_GETT: applies a complex Householder block reflector H from the left to a complex (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.

pure subroutine, public	la_zlarfb_gett (ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)
	ZLARFB_GETT: applies a complex Householder block reflector H from the left to a complex (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.

pure subroutine, public	la_wlarfb_gett (ident, m, n, k, t, ldt, a, lda, b, ldb, work, ldwork)
	WLARFB_GETT: applies a complex Householder block reflector H from the left to a complex (K+M)-by-N "triangular-pentagonal" matrix composed of two block matrices: an upper trapezoidal K-by-N matrix A stored in the array A, and a rectangular M-by-(N-K) matrix B, stored in the array B. The block reflector H is stored in a compact WY-representation, where the elementary reflectors are in the arrays A, B and T. See Further Details section.

pure recursive subroutine, public	la_claunhr_col_getrfnp2 (m, n, a, lda, d, info)
	CLAUNHR_COL_GETRFNP2: computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 \| B12 ] where B11 is n1 by n1, B = [ --—\|--— ] B21 is (m-n1) by n1, [ B21 \| B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. CLAUNHR_COL_GETRFNP2 is called to factorize a block by the blocked routine CLAUNHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, CLAUNHR_COL_GETRFNP2 is self-sufficient and can be used without CLAUNHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

pure recursive subroutine, public	la_zlaunhr_col_getrfnp2 (m, n, a, lda, d, info)
	ZLAUNHR_COL_GETRFNP2: computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine ZUNHR_COL. In ZUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 \| B12 ] where B11 is n1 by n1, B = [ --—\|--— ] B21 is (m-n1) by n1, [ B21 \| B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. ZLAUNHR_COL_GETRFNP2 is called to factorize a block by the blocked routine ZLAUNHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, ZLAUNHR_COL_GETRFNP2 is self-sufficient and can be used without ZLAUNHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

pure recursive subroutine, public	la_wlaunhr_col_getrfnp2 (m, n, a, lda, d, info)
	WLAUNHR_COL_GETRFNP2: computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine WUNHR_COL. In WUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the recursive version of the LU factorization algorithm. Denote A - S by B. The algorithm divides the matrix B into four submatrices: [ B11 \| B12 ] where B11 is n1 by n1, B = [ --—\|--— ] B21 is (m-n1) by n1, [ B21 \| B22 ] B12 is n1 by n2, B22 is (m-n1) by n2, with n1 = min(m,n)/2, n2 = n-n1. The subroutine calls itself to factor B11, solves for B21, solves for B12, updates B22, then calls itself to factor B22. For more details on the recursive LU algorithm, see [2]. WLAUNHR_COL_GETRFNP2 is called to factorize a block by the blocked routine WLAUNHR_COL_GETRFNP, which uses blocked code calling Level 3 BLAS to update the submatrix. However, WLAUNHR_COL_GETRFNP2 is self-sufficient and can be used without WLAUNHR_COL_GETRFNP. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015. [2] "Recursion leads to automatic variable blocking for dense linear algebra algorithms", F. Gustavson, IBM J. of Res. and Dev., vol. 41, no. 6, pp. 737-755, 1997.

pure subroutine, public	la_ctpqrt2 (m, n, l, a, lda, b, ldb, t, ldt, info)
	CTPQRT2: computes a QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_ztpqrt2 (m, n, l, a, lda, b, ldb, t, ldt, info)
	ZTPQRT2: computes a QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_wtpqrt2 (m, n, l, a, lda, b, ldb, t, ldt, info)
	WTPQRT2: computes a QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_ctprfb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)
	CTPRFB: applies a complex "triangular-pentagonal" block reflector H or its conjugate transpose H**H to a complex matrix C, which is composed of two blocks A and B, either from the left or right.

pure subroutine, public	la_ztprfb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)
	ZTPRFB: applies a complex "triangular-pentagonal" block reflector H or its conjugate transpose H**H to a complex matrix C, which is composed of two blocks A and B, either from the left or right.

pure subroutine, public	la_wtprfb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, a, lda, b, ldb, work, ldwork)
	WTPRFB: applies a complex "triangular-pentagonal" block reflector H or its conjugate transpose H**H to a complex matrix C, which is composed of two blocks A and B, either from the left or right.

pure subroutine, public	la_cung2r (m, n, k, a, lda, tau, work, info)
	CUNG2R: generates an m by n complex matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by CGEQRF.

pure subroutine, public	la_zung2r (m, n, k, a, lda, tau, work, info)
	ZUNG2R: generates an m by n complex matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by ZGEQRF.

pure subroutine, public	la_wung2r (m, n, k, a, lda, tau, work, info)
	WUNG2R: generates an m by n complex matrix Q with orthonormal columns, which is defined as the first n columns of a product of k elementary reflectors of order m Q = H(1) H(2) . . . H(k) as returned by WGEQRF.

pure subroutine, public	la_cungqr (m, n, k, a, lda, tau, work, lwork, info)
	CUNGQR: generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by CGEQRF.

pure subroutine, public	la_zungqr (m, n, k, a, lda, tau, work, lwork, info)
	ZUNGQR: generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by ZGEQRF.

pure subroutine, public	la_wungqr (m, n, k, a, lda, tau, work, lwork, info)
	WUNGQR: generates an M-by-N complex matrix Q with orthonormal columns, which is defined as the first N columns of a product of K elementary reflectors of order M Q = H(1) H(2) . . . H(k) as returned by WGEQRF.

pure subroutine, public	la_cungr2 (m, n, k, a, lda, tau, work, info)
	CUNGR2: generates an m by n complex matrix Q with orthonormal rows, which is defined as the last m rows of a product of k elementary reflectors of order n Q = H(1)H H(2)H . . . H(k)**H as returned by CGERQF.

pure subroutine, public	la_zungr2 (m, n, k, a, lda, tau, work, info)
	ZUNGR2: generates an m by n complex matrix Q with orthonormal rows, which is defined as the last m rows of a product of k elementary reflectors of order n Q = H(1)H H(2)H . . . H(k)**H as returned by ZGERQF.

pure subroutine, public	la_wungr2 (m, n, k, a, lda, tau, work, info)
	WUNGR2: generates an m by n complex matrix Q with orthonormal rows, which is defined as the last m rows of a product of k elementary reflectors of order n Q = H(1)H H(2)H . . . H(k)**H as returned by WGERQF.

pure subroutine, public	la_cungrq (m, n, k, a, lda, tau, work, lwork, info)
	CUNGRQ: generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1)H H(2)H . . . H(k)**H as returned by CGERQF.

pure subroutine, public	la_zungrq (m, n, k, a, lda, tau, work, lwork, info)
	ZUNGRQ: generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1)H H(2)H . . . H(k)**H as returned by ZGERQF.

pure subroutine, public	la_wungrq (m, n, k, a, lda, tau, work, lwork, info)
	WUNGRQ: generates an M-by-N complex matrix Q with orthonormal rows, which is defined as the last M rows of a product of K elementary reflectors of order N Q = H(1)H H(2)H . . . H(k)**H as returned by WGERQF.

pure subroutine, public	la_cungtsqr_row (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	CUNGTSQR_ROW: generates an M-by-N complex matrix Q_out with orthonormal columns from the output of CLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by CLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of CLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine CLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which CLATSQR generates the output blocks.

pure subroutine, public	la_zungtsqr_row (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	ZUNGTSQR_ROW: generates an M-by-N complex matrix Q_out with orthonormal columns from the output of ZLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by ZLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of ZLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine ZLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which ZLATSQR generates the output blocks.

pure subroutine, public	la_wungtsqr_row (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	WUNGTSQR_ROW: generates an M-by-N complex matrix Q_out with orthonormal columns from the output of WLATSQR. These N orthonormal columns are the first N columns of a product of complex unitary matrices Q(k)_in of order M, which are returned by WLATSQR in a special format. Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). The input matrices Q(k)_in are stored in row and column blocks in A. See the documentation of WLATSQR for more details on the format of Q(k)_in, where each Q(k)_in is represented by block Householder transformations. This routine calls an auxiliary routine WLARFB_GETT, where the computation is performed on each individual block. The algorithm first sweeps NB-sized column blocks from the right to left starting in the bottom row block and continues to the top row block (hence _ROW in the routine name). This sweep is in reverse order of the order in which WLATSQR generates the output blocks.

pure subroutine, public	la_cunm2r (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	CUNM2R: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*H C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**H if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_zunm2r (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	ZUNM2R: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*H C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**H if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by ZGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_wunm2r (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	WUNM2R: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*H C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**H if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by WGEQRF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_cunmqr (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	CUNMQR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by CGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_zunmqr (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	ZUNMQR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by ZGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_wunmqr (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	WUNMQR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) . . . H(k) as returned by WGEQRF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_cunmr2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	CUNMR2: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*H C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)H as returned by CGERQF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_zunmr2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	ZUNMR2: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*H C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)H as returned by ZGERQF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_wunmr2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
	WUNMR2: overwrites the general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q*H C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * QH if SIDE = 'R' and TRANS = 'C', where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)H as returned by WGERQF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

pure subroutine, public	la_cunmrq (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	CUNMRQ: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)H as returned by CGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_zunmrq (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	ZUNMRQ: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)H as returned by ZGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_wunmrq (side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info)
	WUNMRQ: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)H H(2)H . . . H(k)H as returned by WGERQF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_cgemqrt (side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)
	CGEMQRT: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by CGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_zgemqrt (side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)
	ZGEMQRT: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by ZGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_wgemqrt (side, trans, m, n, k, nb, v, ldv, t, ldt, c, ldc, work, info)
	WGEMQRT: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q C C Q TRANS = 'C': QH C C QH where Q is a complex orthogonal matrix defined as the product of K elementary reflectors: Q = H(1) H(2) . . . H(K) = I - V T V**H generated using the compact WY representation as returned by WGEQRT. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

pure subroutine, public	la_cgeqr2 (m, n, a, lda, tau, work, info)
	CGEQR2: computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix; 0 is a (m-n)-by-n zero matrix, if m > n.

pure subroutine, public	la_zgeqr2 (m, n, a, lda, tau, work, info)
	ZGEQR2: computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix; 0 is a (m-n)-by-n zero matrix, if m > n.

pure subroutine, public	la_wgeqr2 (m, n, a, lda, tau, work, info)
	WGEQR2: computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix; 0 is a (m-n)-by-n zero matrix, if m > n.

subroutine, public	la_cgeqr2p (m, n, a, lda, tau, work, info)
	CGEQR2P: computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.

subroutine, public	la_zgeqr2p (m, n, a, lda, tau, work, info)
	ZGEQR2P: computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.

subroutine, public	la_wgeqr2p (m, n, a, lda, tau, work, info)
	WGEQR2P: computes a QR factorization of a complex m-by-n matrix A: A = Q * ( R ), ( 0 ) where: Q is a m-by-m orthogonal matrix; R is an upper-triangular n-by-n matrix with nonnegative diagonal entries; 0 is a (m-n)-by-n zero matrix, if m > n.

pure subroutine, public	la_cgeqrf (m, n, a, lda, tau, work, lwork, info)
	CGEQRF: computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

pure subroutine, public	la_zgeqrf (m, n, a, lda, tau, work, lwork, info)
	ZGEQRF: computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

pure subroutine, public	la_wgeqrf (m, n, a, lda, tau, work, lwork, info)
	WGEQRF: computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

subroutine, public	la_cgeqrfp (m, n, a, lda, tau, work, lwork, info)
	CGEQR2P computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.

subroutine, public	la_zgeqrfp (m, n, a, lda, tau, work, lwork, info)
	ZGEQR2P computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.

subroutine, public	la_wgeqrfp (m, n, a, lda, tau, work, lwork, info)
	WGEQR2P computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix with nonnegative diagonal entries; 0 is a (M-N)-by-N zero matrix, if M > N.

pure subroutine, public	la_cgeqrt2 (m, n, a, lda, t, ldt, info)
	CGEQRT2: computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q.

pure subroutine, public	la_zgeqrt2 (m, n, a, lda, t, ldt, info)
	ZGEQRT2: computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q.

pure subroutine, public	la_wgeqrt2 (m, n, a, lda, t, ldt, info)
	WGEQRT2: computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q.

pure recursive subroutine, public	la_cgeqrt3 (m, n, a, lda, t, ldt, info)
	CGEQRT3: recursively computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

pure recursive subroutine, public	la_zgeqrt3 (m, n, a, lda, t, ldt, info)
	ZGEQRT3: recursively computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

pure recursive subroutine, public	la_wgeqrt3 (m, n, a, lda, t, ldt, info)
	WGEQRT3: recursively computes a QR factorization of a complex M-by-N matrix A, using the compact WY representation of Q. Based on the algorithm of Elmroth and Gustavson, IBM J. Res. Develop. Vol 44 No. 4 July 2000.

pure subroutine, public	la_cgerq2 (m, n, a, lda, tau, work, info)
	CGERQ2: computes an RQ factorization of a complex m by n matrix A: A = R * Q.

pure subroutine, public	la_zgerq2 (m, n, a, lda, tau, work, info)
	ZGERQ2: computes an RQ factorization of a complex m by n matrix A: A = R * Q.

pure subroutine, public	la_wgerq2 (m, n, a, lda, tau, work, info)
	WGERQ2: computes an RQ factorization of a complex m by n matrix A: A = R * Q.

pure subroutine, public	la_cgerqf (m, n, a, lda, tau, work, lwork, info)
	CGERQF: computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.

pure subroutine, public	la_zgerqf (m, n, a, lda, tau, work, lwork, info)
	ZGERQF: computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.

pure subroutine, public	la_wgerqf (m, n, a, lda, tau, work, lwork, info)
	WGERQF: computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.

pure subroutine, public	la_cggqrf (n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)
	CGGQRF: computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZH (inv(T)*R) where inv(B) denotes the inverse of the matrix B, and Z' denotes the conjugate transpose of matrix Z.

pure subroutine, public	la_zggqrf (n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)
	ZGGQRF: computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZH (inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z*H denotes the conjugate transpose of matrix Z.

pure subroutine, public	la_wggqrf (n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)
	WGGQRF: computes a generalized QR factorization of an N-by-M matrix A and an N-by-P matrix B: A = QR, B = QTZ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if N >= M, R = ( R11 ) M , or if N < M, R = ( R11 R12 ) N, ( 0 ) N-M N M-N M where R11 is upper triangular, and if N <= P, T = ( 0 T12 ) N, or if N > P, T = ( T11 ) N-P, P-N N ( T21 ) P P where T12 or T21 is upper triangular. In particular, if B is square and nonsingular, the GQR factorization of A and B implicitly gives the QR factorization of inv(B)A: inv(B)A = ZH (inv(T)R) where inv(B) denotes the inverse of the matrix B, and Z*H denotes the conjugate transpose of matrix Z.

pure subroutine, public	la_cggrqf (m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)
	CGGRQF: computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZH where inv(B) denotes the inverse of the matrix B, and Z*H denotes the conjugate transpose of the matrix Z.

pure subroutine, public	la_zggrqf (m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)
	ZGGRQF: computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZH where inv(B) denotes the inverse of the matrix B, and Z*H denotes the conjugate transpose of the matrix Z.

pure subroutine, public	la_wggrqf (m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)
	WGGRQF: computes a generalized RQ factorization of an M-by-N matrix A and a P-by-N matrix B: A = RQ, B = ZTQ, where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix, and R and T assume one of the forms: if M <= N, R = ( 0 R12 ) M, or if M > N, R = ( R11 ) M-N, N-M M ( R21 ) N N where R12 or R21 is upper triangular, and if P >= N, T = ( T11 ) N , or if P < N, T = ( T11 T12 ) P, ( 0 ) P-N P N-P N where T11 is upper triangular. In particular, if B is square and nonsingular, the GRQ factorization of A and B implicitly gives the RQ factorization of Ainv(B): Ainv(B) = (Rinv(T))ZH where inv(B) denotes the inverse of the matrix B, and Z*H denotes the conjugate transpose of the matrix Z.

pure subroutine, public	la_claqp2 (m, n, offset, a, lda, jpvt, tau, vn1, vn2, work)
	CLAQP2: computes a QR factorization with column pivoting of the block A(OFFSET+1:M,1:N). The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_zlaqp2 (m, n, offset, a, lda, jpvt, tau, vn1, vn2, work)
	ZLAQP2: computes a QR factorization with column pivoting of the block A(OFFSET+1:M,1:N). The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_wlaqp2 (m, n, offset, a, lda, jpvt, tau, vn1, vn2, work)
	WLAQP2: computes a QR factorization with column pivoting of the block A(OFFSET+1:M,1:N). The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_claqps (m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)
	CLAQPS: computes a step of QR factorization with column pivoting of a complex M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_zlaqps (m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)
	ZLAQPS: computes a step of QR factorization with column pivoting of a complex M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_wlaqps (m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)
	WLAQPS: computes a step of QR factorization with column pivoting of a complex M-by-N matrix A by using Blas-3. It tries to factorize NB columns from A starting from the row OFFSET+1, and updates all of the matrix with Blas-3 xGEMM. In some cases, due to catastrophic cancellations, it cannot factorize NB columns. Hence, the actual number of factorized columns is returned in KB. Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

pure subroutine, public	la_claunhr_col_getrfnp (m, n, a, lda, d, info)
	CLAUNHR_COL_GETRFNP: computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine CUNHR_COL. In CUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine CLAUNHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

pure subroutine, public	la_zlaunhr_col_getrfnp (m, n, a, lda, d, info)
	ZLAUNHR_COL_GETRFNP: computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine ZUNHR_COL. In ZUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine ZLAUNHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

pure subroutine, public	la_wlaunhr_col_getrfnp (m, n, a, lda, d, info)
	WLAUNHR_COL_GETRFNP: computes the modified LU factorization without pivoting of a complex general M-by-N matrix A. The factorization has the form: A - S = L * U, where: S is a m-by-n diagonal sign matrix with the diagonal D, so that D(i) = S(i,i), 1 <= i <= min(M,N). The diagonal D is constructed as D(i)=-SIGN(A(i,i)), where A(i,i) is the value after performing i-1 steps of Gaussian elimination. This means that the diagonal element at each step of "modified" Gaussian elimination is at least one in absolute value (so that division-by-zero not not possible during the division by the diagonal element); L is a M-by-N lower triangular matrix with unit diagonal elements (lower trapezoidal if M > N); and U is a M-by-N upper triangular matrix (upper trapezoidal if M < N). This routine is an auxiliary routine used in the Householder reconstruction routine WUNHR_COL. In WUNHR_COL, this routine is applied to an M-by-N matrix A with orthonormal columns, where each element is bounded by one in absolute value. With the choice of the matrix S above, one can show that the diagonal element at each step of Gaussian elimination is the largest (in absolute value) in the column on or below the diagonal, so that no pivoting is required for numerical stability [1]. For more details on the Householder reconstruction algorithm, including the modified LU factorization, see [1]. This is the blocked right-looking version of the algorithm, calling Level 3 BLAS to update the submatrix. To factorize a block, this routine calls the recursive routine WLAUNHR_COL_GETRFNP2. [1] "Reconstructing Householder vectors from tall-skinny QR", G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen, E. Solomonik, J. Parallel Distrib. Comput., vol. 85, pp. 3-31, 2015.

pure subroutine, public	la_ctpmqrt (side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)
	CTPMQRT: applies a complex orthogonal matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.

pure subroutine, public	la_ztpmqrt (side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)
	ZTPMQRT: applies a complex orthogonal matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.

pure subroutine, public	la_wtpmqrt (side, trans, m, n, k, l, nb, v, ldv, t, ldt, a, lda, b, ldb, work, info)
	WTPMQRT: applies a complex orthogonal matrix Q obtained from a "triangular-pentagonal" complex block reflector H to a general complex matrix C, which consists of two blocks A and B.

pure subroutine, public	la_ctpqrt (m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)
	CTPQRT: computes a blocked QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_ztpqrt (m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)
	ZTPQRT: computes a blocked QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_wtpqrt (m, n, l, nb, a, lda, b, ldb, t, ldt, work, info)
	WTPQRT: computes a blocked QR factorization of a complex "triangular-pentagonal" matrix C, which is composed of a triangular block A and pentagonal block B, using the compact WY representation for Q.

pure subroutine, public	la_cunhr_col (m, n, nb, a, lda, t, ldt, d, info)
	CUNHR_COL: takes an M-by-N complex matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as CGEQRT).

pure subroutine, public	la_zunhr_col (m, n, nb, a, lda, t, ldt, d, info)
	ZUNHR_COL: takes an M-by-N complex matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as ZGEQRT).

pure subroutine, public	la_wunhr_col (m, n, nb, a, lda, t, ldt, d, info)
	WUNHR_COL: takes an M-by-N complex matrix Q_in with orthonormal columns as input, stored in A, and performs Householder Reconstruction (HR), i.e. reconstructs Householder vectors V(i) implicitly representing another M-by-N matrix Q_out, with the property that Q_in = Q_out*S, where S is an N-by-N diagonal matrix with diagonal entries equal to +1 or -1. The Householder vectors (columns V(i) of V) are stored in A on output, and the diagonal entries of S are stored in D. Block reflectors are also returned in T (same output format as WGEQRT).

pure subroutine, public	la_cgeqp3 (m, n, a, lda, jpvt, tau, work, lwork, rwork, info)
	CGEQP3: computes a QR factorization with column pivoting of a matrix A: AP = QR using Level 3 BLAS.

pure subroutine, public	la_zgeqp3 (m, n, a, lda, jpvt, tau, work, lwork, rwork, info)
	ZGEQP3: computes a QR factorization with column pivoting of a matrix A: AP = QR using Level 3 BLAS.

pure subroutine, public	la_wgeqp3 (m, n, a, lda, jpvt, tau, work, lwork, rwork, info)
	WGEQP3: computes a QR factorization with column pivoting of a matrix A: AP = QR using Level 3 BLAS.

pure subroutine, public	la_cgeqrt (m, n, nb, a, lda, t, ldt, work, info)
	CGEQRT: computes a blocked QR factorization of a complex M-by-N matrix A using the compact WY representation of Q.

pure subroutine, public	la_zgeqrt (m, n, nb, a, lda, t, ldt, work, info)
	ZGEQRT: computes a blocked QR factorization of a complex M-by-N matrix A using the compact WY representation of Q.

pure subroutine, public	la_wgeqrt (m, n, nb, a, lda, t, ldt, work, info)
	WGEQRT: computes a blocked QR factorization of a complex M-by-N matrix A using the compact WY representation of Q.

pure subroutine, public	la_clamtsqr (side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)
	CLAMTSQR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CLATSQR)

pure subroutine, public	la_zlamtsqr (side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)
	ZLAMTSQR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (ZLATSQR)

pure subroutine, public	la_wlamtsqr (side, trans, m, n, k, mb, nb, a, lda, t, ldt, c, ldc, work, lwork, info)
	WLAMTSQR: overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (WLATSQR)

pure subroutine, public	la_clatsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	CLATSQR: computes a blocked Tall-Skinny QR factorization of a complex M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.

pure subroutine, public	la_zlatsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	ZLATSQR: computes a blocked Tall-Skinny QR factorization of a complex M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.

pure subroutine, public	la_wlatsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	WLATSQR: computes a blocked Tall-Skinny QR factorization of a complex M-by-N matrix A for M >= N: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix, stored on exit in an implicit form in the elements below the diagonal of the array A and in the elements of the array T; R is an upper-triangular N-by-N matrix, stored on exit in the elements on and above the diagonal of the array A. 0 is a (M-N)-by-N zero matrix, and is not stored.

pure subroutine, public	la_cungtsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	CUNGTSQR: generates an M-by-N complex matrix Q_out with orthonormal columns, which are the first N columns of a product of comlpex unitary matrices of order M which are returned by CLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for CLATSQR.

pure subroutine, public	la_zungtsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	ZUNGTSQR: generates an M-by-N complex matrix Q_out with orthonormal columns, which are the first N columns of a product of comlpex unitary matrices of order M which are returned by ZLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for ZLATSQR.

pure subroutine, public	la_wungtsqr (m, n, mb, nb, a, lda, t, ldt, work, lwork, info)
	WUNGTSQR: generates an M-by-N complex matrix Q_out with orthonormal columns, which are the first N columns of a product of comlpex unitary matrices of order M which are returned by WLATSQR Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ). See the documentation for WLATSQR.

pure subroutine, public	la_cgemqr (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)
	CGEMQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CGEQR)

pure subroutine, public	la_zgemqr (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)
	ZGEMQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (ZGEQR)

pure subroutine, public	la_wgemqr (side, trans, m, n, k, a, lda, t, tsize, c, ldc, work, lwork, info)
	WGEMQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q*H C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (WGEQR)

pure subroutine, public	la_cgeqr (m, n, a, lda, t, tsize, work, lwork, info)
	CGEQR: computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

pure subroutine, public	la_zgeqr (m, n, a, lda, t, tsize, work, lwork, info)
	ZGEQR: computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

pure subroutine, public	la_wgeqr (m, n, a, lda, t, tsize, work, lwork, info)
	WGEQR: computes a QR factorization of a complex M-by-N matrix A: A = Q * ( R ), ( 0 ) where: Q is a M-by-M orthogonal matrix; R is an upper-triangular N-by-N matrix; 0 is a (M-N)-by-N zero matrix, if M > N.

pure subroutine, public	la_cgetsqrhrt (m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)
	CGETSQRHRT: computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in CGEQRT (Q is in blocked compact WY-representation). See the documentation of CGEQRT for more details on the format.

pure subroutine, public	la_zgetsqrhrt (m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)
	ZGETSQRHRT: computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in ZGEQRT (Q is in blocked compact WY-representation). See the documentation of ZGEQRT for more details on the format.

pure subroutine, public	la_wgetsqrhrt (m, n, mb1, nb1, nb2, a, lda, t, ldt, work, lwork, info)
	WGETSQRHRT: computes a NB2-sized column blocked QR-factorization of a complex M-by-N matrix A with M >= N, A = Q * R. The routine uses internally a NB1-sized column blocked and MB1-sized row blocked TSQR-factorization and perfors the reconstruction of the Householder vectors from the TSQR output. The routine also converts the R_tsqr factor from the TSQR-factorization output into the R factor that corresponds to the Householder QR-factorization, A = Q_tsqr * R_tsqr = Q * R. The output Q and R factors are stored in the same format as in WGEQRT (Q is in blocked compact WY-representation). See the documentation of WGEQRT for more details on the format.

Detailed Description

QR and RQ factorizations: blocked, tall-skinny, pivoted and triangular-pentagonal variants.

Function/Subroutine Documentation

◆ la_cgemqr()

pure subroutine, public la_lapack_orthogonal_factors_qr::la_cgemqr	(	character, intent(in)	side,
		character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	t,
		integer(ilp), intent(in)	tsize,
		complex(sp), dimension(ldc,*), intent(inout)	c,
		integer(ilp), intent(in)	ldc,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

CGEMQR: overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q**H * C C * Q**H where Q is a complex unitary matrix defined as the product of blocked elementary reflectors computed by tall skinny QR factorization (CGEQR)