|
| pure recursive subroutine, public | la_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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': 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) = 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_lapack_orthogonal_factors_qr::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': 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) = 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_lapack_orthogonal_factors_qr::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': 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) = 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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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 = Q*R, B = Q*T*Z, 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 = Z**T*(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_lapack_orthogonal_factors_qr::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 = Q*R, B = Q*T*Z, 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 = Z**T*(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_lapack_orthogonal_factors_qr::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 = Q*R, B = Q*T*Z, 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 = Z**T*(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_lapack_orthogonal_factors_qr::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 = R*Q, B = Z*T*Q, 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 A*inv(B): A*inv(B) = (R*inv(T))*Z**T where inv(B) denotes the inverse of the matrix B, and Z**T denotes the transpose of the matrix Z.
|
| |
| pure subroutine, public | la_lapack_orthogonal_factors_qr::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 = R*Q, B = Z*T*Q, 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 A*inv(B): A*inv(B) = (R*inv(T))*Z**T where inv(B) denotes the inverse of the matrix B, and Z**T denotes the transpose of the matrix Z.
|
| |
| pure subroutine, public | la_lapack_orthogonal_factors_qr::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 = R*Q, B = Z*T*Q, 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 A*inv(B): A*inv(B) = (R*inv(T))*Z**T where inv(B) denotes the inverse of the matrix B, and Z**T denotes the transpose of the matrix Z.
|
| |
| pure subroutine, public | la_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::la_sgeqp3 (m, n, a, lda, jpvt, tau, work, lwork, info) |
| | SGEQP3: computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_orthogonal_factors_qr::la_dgeqp3 (m, n, a, lda, jpvt, tau, work, lwork, info) |
| | DGEQP3: computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_orthogonal_factors_qr::la_qgeqp3 (m, n, a, lda, jpvt, tau, work, lwork, info) |
| | QGEQP3: computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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 * 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 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_lapack_orthogonal_factors_qr::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 * 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 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_lapack_orthogonal_factors_qr::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 * 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 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_lapack_orthogonal_factors_qr::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 * Q**H 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_lapack_orthogonal_factors_qr::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 * Q**H 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_lapack_orthogonal_factors_qr::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 * Q**H 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_lapack_orthogonal_factors_qr::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': Q**H C C Q**H 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_lapack_orthogonal_factors_qr::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': Q**H C C Q**H 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_lapack_orthogonal_factors_qr::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': Q**H C C Q**H 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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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 = Q*R, B = Q*T*Z, 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 = Z**H * (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_lapack_orthogonal_factors_qr::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 = Q*R, B = Q*T*Z, 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 = Z**H * (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_lapack_orthogonal_factors_qr::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 = Q*R, B = Q*T*Z, 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 = Z**H * (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_lapack_orthogonal_factors_qr::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 = R*Q, B = Z*T*Q, 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 A*inv(B): A*inv(B) = (R*inv(T))*Z**H 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_lapack_orthogonal_factors_qr::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 = R*Q, B = Z*T*Q, 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 A*inv(B): A*inv(B) = (R*inv(T))*Z**H 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_lapack_orthogonal_factors_qr::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 = R*Q, B = Z*T*Q, 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 A*inv(B): A*inv(B) = (R*inv(T))*Z**H 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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::la_cgeqp3 (m, n, a, lda, jpvt, tau, work, lwork, rwork, info) |
| | CGEQP3: computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_orthogonal_factors_qr::la_zgeqp3 (m, n, a, lda, jpvt, tau, work, lwork, rwork, info) |
| | ZGEQP3: computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_orthogonal_factors_qr::la_wgeqp3 (m, n, a, lda, jpvt, tau, work, lwork, rwork, info) |
| | WGEQP3: computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.
|
| |
| pure subroutine, public | la_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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_lapack_orthogonal_factors_qr::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.
|
| |
1.13.2