|
fortran-lapack
|
RZ factorization: trapezoidal reduction and its reflectors. More...
Functions/Subroutines | |
| pure subroutine, public | la_slarz (side, m, n, l, v, incv, tau, c, ldc, work) |
| SLARZ: applies a real elementary reflector H to a real M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix. H is a product of k elementary reflectors as returned by STZRZF. | |
| pure subroutine, public | la_dlarz (side, m, n, l, v, incv, tau, c, ldc, work) |
| DLARZ: applies a real elementary reflector H to a real M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix. H is a product of k elementary reflectors as returned by DTZRZF. | |
| pure subroutine, public | la_qlarz (side, m, n, l, v, incv, tau, c, ldc, work) |
| QLARZ: applies a real elementary reflector H to a real M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix. H is a product of k elementary reflectors as returned by QTZRZF. | |
| pure subroutine, public | la_slarzb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork) |
| SLARZB: applies a real block reflector H or its transpose H**T to a real distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported. | |
| pure subroutine, public | la_dlarzb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork) |
| DLARZB: applies a real block reflector H or its transpose H**T to a real distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported. | |
| pure subroutine, public | la_qlarzb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork) |
| QLARZB: applies a real block reflector H or its transpose H**T to a real distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported. | |
| pure subroutine, public | la_slarzt (direct, storev, n, k, v, ldv, tau, t, ldt) |
| SLARZT: forms the triangular factor T of a real block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**T If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**T * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported. | |
| pure subroutine, public | la_dlarzt (direct, storev, n, k, v, ldv, tau, t, ldt) |
| DLARZT: forms the triangular factor T of a real block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**T If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**T * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported. | |
| pure subroutine, public | la_qlarzt (direct, storev, n, k, v, ldv, tau, t, ldt) |
| QLARZT: forms the triangular factor T of a real block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**T If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**T * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported. | |
| pure subroutine, public | la_sormr3 (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) |
| SORMR3: 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 = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'C', 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 STZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'. | |
| pure subroutine, public | la_dormr3 (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) |
| DORMR3: 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 = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'C', 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 DTZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'. | |
| pure subroutine, public | la_qormr3 (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) |
| QORMR3: 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 = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'C', 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 QTZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'. | |
| pure subroutine, public | la_sormrz (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) |
| SORMRZ: 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 STZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'. | |
| pure subroutine, public | la_dormrz (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) |
| DORMRZ: 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 DTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'. | |
| pure subroutine, public | la_qormrz (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) |
| QORMRZ: 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 QTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'. | |
| pure subroutine, public | la_slatrz (m, n, l, a, lda, tau, work) |
| SLATRZ: factors the M-by-(M+L) real upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z, by means of orthogonal transformations. Z is an (M+L)-by-(M+L) orthogonal matrix and, R and A1 are M-by-M upper triangular matrices. | |
| pure subroutine, public | la_dlatrz (m, n, l, a, lda, tau, work) |
| DLATRZ: factors the M-by-(M+L) real upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z, by means of orthogonal transformations. Z is an (M+L)-by-(M+L) orthogonal matrix and, R and A1 are M-by-M upper triangular matrices. | |
| pure subroutine, public | la_qlatrz (m, n, l, a, lda, tau, work) |
| QLATRZ: factors the M-by-(M+L) real upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z, by means of orthogonal transformations. Z is an (M+L)-by-(M+L) orthogonal matrix and, R and A1 are M-by-M upper triangular matrices. | |
| pure subroutine, public | la_stzrzf (m, n, a, lda, tau, work, lwork, info) |
| STZRZF: reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A to upper triangular form by means of orthogonal transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N orthogonal matrix and R is an M-by-M upper triangular matrix. | |
| pure subroutine, public | la_dtzrzf (m, n, a, lda, tau, work, lwork, info) |
| DTZRZF: reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A to upper triangular form by means of orthogonal transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N orthogonal matrix and R is an M-by-M upper triangular matrix. | |
| pure subroutine, public | la_qtzrzf (m, n, a, lda, tau, work, lwork, info) |
| QTZRZF: reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A to upper triangular form by means of orthogonal transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N orthogonal matrix and R is an M-by-M upper triangular matrix. | |
| pure subroutine, public | la_clarz (side, m, n, l, v, incv, tau, c, ldc, work) |
| CLARZ: applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**H where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply H**H (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by CTZRZF. | |
| pure subroutine, public | la_zlarz (side, m, n, l, v, incv, tau, c, ldc, work) |
| ZLARZ: applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**H where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply H**H (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by ZTZRZF. | |
| pure subroutine, public | la_wlarz (side, m, n, l, v, incv, tau, c, ldc, work) |
| WLARZ: applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**H where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply H**H (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by WTZRZF. | |
| pure subroutine, public | la_clarzb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork) |
| CLARZB: applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported. | |
| pure subroutine, public | la_zlarzb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork) |
| ZLARZB: applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported. | |
| pure subroutine, public | la_wlarzb (side, trans, direct, storev, m, n, k, l, v, ldv, t, ldt, c, ldc, work, ldwork) |
| WLARZB: applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported. | |
| pure subroutine, public | la_clarzt (direct, storev, n, k, v, ldv, tau, t, ldt) |
| CLARZT: forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**H If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**H * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported. | |
| pure subroutine, public | la_zlarzt (direct, storev, n, k, v, ldv, tau, t, ldt) |
| ZLARZT: forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**H If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**H * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported. | |
| pure subroutine, public | la_wlarzt (direct, storev, n, k, v, ldv, tau, t, ldt) |
| WLARZT: forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**H If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**H * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported. | |
| pure subroutine, public | la_clatrz (m, n, l, a, lda, tau, work) |
| CLATRZ: factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices. | |
| pure subroutine, public | la_zlatrz (m, n, l, a, lda, tau, work) |
| ZLATRZ: factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices. | |
| pure subroutine, public | la_wlatrz (m, n, l, a, lda, tau, work) |
| WLATRZ: factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices. | |
| pure subroutine, public | la_ctzrzf (m, n, a, lda, tau, work, lwork, info) |
| CTZRZF: reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix. | |
| pure subroutine, public | la_ztzrzf (m, n, a, lda, tau, work, lwork, info) |
| ZTZRZF: reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix. | |
| pure subroutine, public | la_wtzrzf (m, n, a, lda, tau, work, lwork, info) |
| WTZRZF: reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix. | |
| pure subroutine, public | la_cunmr3 (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) |
| CUNMR3: 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 CTZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'. | |
| pure subroutine, public | la_zunmr3 (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) |
| ZUNMR3: 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 ZTZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'. | |
| pure subroutine, public | la_wunmr3 (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info) |
| WUNMR3: 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 WTZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'. | |
| pure subroutine, public | la_cunmrz (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) |
| CUNMRZ: 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 CTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'. | |
| pure subroutine, public | la_zunmrz (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) |
| ZUNMRZ: 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 ZTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'. | |
| pure subroutine, public | la_wunmrz (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info) |
| WUNMRZ: 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 WTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'. | |
RZ factorization: trapezoidal reduction and its reflectors.
| pure subroutine, public la_lapack_orthogonal_factors_rz::la_clarz | ( | character, intent(in) | side, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | l, | ||
| complex(sp), dimension(*), intent(in) | v, | ||
| integer(ilp), intent(in) | incv, | ||
| complex(sp), intent(in) | tau, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| complex(sp), dimension(*), intent(out) | work ) |
CLARZ: applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**H where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply H**H (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by CTZRZF.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_clarzb | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| character, intent(in) | direct, | ||
| character, intent(in) | storev, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| complex(sp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(sp), dimension(ldt,*), intent(inout) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| complex(sp), dimension(ldwork,*), intent(out) | work, | ||
| integer(ilp), intent(in) | ldwork ) |
CLARZB: applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_clarzt | ( | character, intent(in) | direct, |
| character, intent(in) | storev, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(sp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(sp), dimension(*), intent(in) | tau, | ||
| complex(sp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt ) |
CLARZT: forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**H If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**H * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_clatrz | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | l, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(out) | tau, | ||
| complex(sp), dimension(*), intent(out) | work ) |
CLATRZ: factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_ctzrzf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(out) | tau, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CTZRZF: reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_cunmr3 | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| complex(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(in) | tau, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
CUNMR3: 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 CTZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_cunmrz | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(in) | tau, | ||
| complex(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CUNMRZ: 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 CTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_dlarz | ( | character, intent(in) | side, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | l, | ||
| real(dp), dimension(*), intent(in) | v, | ||
| integer(ilp), intent(in) | incv, | ||
| real(dp), intent(in) | tau, | ||
| real(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| real(dp), dimension(*), intent(out) | work ) |
DLARZ: applies a real elementary reflector H to a real M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix. H is a product of k elementary reflectors as returned by DTZRZF.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_dlarzb | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| character, intent(in) | direct, | ||
| character, intent(in) | storev, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| real(dp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(dp), dimension(ldt,*), intent(inout) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| real(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| real(dp), dimension(ldwork,*), intent(out) | work, | ||
| integer(ilp), intent(in) | ldwork ) |
DLARZB: applies a real block reflector H or its transpose H**T to a real distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_dlarzt | ( | character, intent(in) | direct, |
| character, intent(in) | storev, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(dp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(dp), dimension(*), intent(in) | tau, | ||
| real(dp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt ) |
DLARZT: forms the triangular factor T of a real block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**T If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**T * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_dlatrz | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | l, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | tau, | ||
| real(dp), dimension(*), intent(out) | work ) |
DLATRZ: factors the M-by-(M+L) real upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z, by means of orthogonal transformations. Z is an (M+L)-by-(M+L) orthogonal matrix and, R and A1 are M-by-M upper triangular matrices.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_dormr3 | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| real(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(in) | tau, | ||
| real(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
DORMR3: 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 = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'C', 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 DTZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_dormrz | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(in) | tau, | ||
| real(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DORMRZ: 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 DTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_dtzrzf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(out) | tau, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DTZRZF: reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A to upper triangular form by means of orthogonal transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N orthogonal matrix and R is an M-by-M upper triangular matrix.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_qlarz | ( | character, intent(in) | side, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | l, | ||
| real(qp), dimension(*), intent(in) | v, | ||
| integer(ilp), intent(in) | incv, | ||
| real(qp), intent(in) | tau, | ||
| real(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| real(qp), dimension(*), intent(out) | work ) |
QLARZ: applies a real elementary reflector H to a real M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix. H is a product of k elementary reflectors as returned by QTZRZF.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_qlarzb | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| character, intent(in) | direct, | ||
| character, intent(in) | storev, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| real(qp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(qp), dimension(ldt,*), intent(inout) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| real(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| real(qp), dimension(ldwork,*), intent(out) | work, | ||
| integer(ilp), intent(in) | ldwork ) |
QLARZB: applies a real block reflector H or its transpose H**T to a real distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_qlarzt | ( | character, intent(in) | direct, |
| character, intent(in) | storev, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(qp), dimension(*), intent(in) | tau, | ||
| real(qp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt ) |
QLARZT: forms the triangular factor T of a real block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**T If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**T * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_qlatrz | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | l, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | tau, | ||
| real(qp), dimension(*), intent(out) | work ) |
QLATRZ: factors the M-by-(M+L) real upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z, by means of orthogonal transformations. Z is an (M+L)-by-(M+L) orthogonal matrix and, R and A1 are M-by-M upper triangular matrices.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_qormr3 | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | tau, | ||
| real(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
QORMR3: 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 = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'C', 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 QTZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_qormrz | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | tau, | ||
| real(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QORMRZ: 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 QTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_qtzrzf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(out) | tau, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QTZRZF: reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A to upper triangular form by means of orthogonal transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N orthogonal matrix and R is an M-by-M upper triangular matrix.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_slarz | ( | character, intent(in) | side, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | l, | ||
| real(sp), dimension(*), intent(in) | v, | ||
| integer(ilp), intent(in) | incv, | ||
| real(sp), intent(in) | tau, | ||
| real(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| real(sp), dimension(*), intent(out) | work ) |
SLARZ: applies a real elementary reflector H to a real M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**T where tau is a real scalar and v is a real vector. If tau = 0, then H is taken to be the unit matrix. H is a product of k elementary reflectors as returned by STZRZF.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_slarzb | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| character, intent(in) | direct, | ||
| character, intent(in) | storev, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| real(sp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(sp), dimension(ldt,*), intent(inout) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| real(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| real(sp), dimension(ldwork,*), intent(out) | work, | ||
| integer(ilp), intent(in) | ldwork ) |
SLARZB: applies a real block reflector H or its transpose H**T to a real distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_slarzt | ( | character, intent(in) | direct, |
| character, intent(in) | storev, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| real(sp), dimension(*), intent(in) | tau, | ||
| real(sp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt ) |
SLARZT: forms the triangular factor T of a real block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**T If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**T * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_slatrz | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | l, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | tau, | ||
| real(sp), dimension(*), intent(out) | work ) |
SLATRZ: factors the M-by-(M+L) real upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z, by means of orthogonal transformations. Z is an (M+L)-by-(M+L) orthogonal matrix and, R and A1 are M-by-M upper triangular matrices.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_sormr3 | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | tau, | ||
| real(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
SORMR3: 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 = 'C', or C * Q if SIDE = 'R' and TRANS = 'N', or C * Q**T if SIDE = 'R' and TRANS = 'C', 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 STZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_sormrz | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | tau, | ||
| real(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SORMRZ: 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 STZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_stzrzf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(out) | tau, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
STZRZF: reduces the M-by-N ( M<=N ) real upper trapezoidal matrix A to upper triangular form by means of orthogonal transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N orthogonal matrix and R is an M-by-M upper triangular matrix.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_wlarz | ( | character, intent(in) | side, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | l, | ||
| complex(qp), dimension(*), intent(in) | v, | ||
| integer(ilp), intent(in) | incv, | ||
| complex(qp), intent(in) | tau, | ||
| complex(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| complex(qp), dimension(*), intent(out) | work ) |
WLARZ: applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**H where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply H**H (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by WTZRZF.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_wlarzb | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| character, intent(in) | direct, | ||
| character, intent(in) | storev, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| complex(qp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(qp), dimension(ldt,*), intent(inout) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| complex(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| complex(qp), dimension(ldwork,*), intent(out) | work, | ||
| integer(ilp), intent(in) | ldwork ) |
WLARZB: applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_wlarzt | ( | character, intent(in) | direct, |
| character, intent(in) | storev, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(qp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(qp), dimension(*), intent(in) | tau, | ||
| complex(qp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt ) |
WLARZT: forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**H If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**H * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_wlatrz | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | l, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(out) | tau, | ||
| complex(qp), dimension(*), intent(out) | work ) |
WLATRZ: factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_wtzrzf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(out) | tau, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WTZRZF: reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_wunmr3 | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| complex(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(in) | tau, | ||
| complex(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
WUNMR3: 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 WTZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_wunmrz | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(in) | tau, | ||
| complex(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WUNMRZ: 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 WTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_zlarz | ( | character, intent(in) | side, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | l, | ||
| complex(dp), dimension(*), intent(in) | v, | ||
| integer(ilp), intent(in) | incv, | ||
| complex(dp), intent(in) | tau, | ||
| complex(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| complex(dp), dimension(*), intent(out) | work ) |
ZLARZ: applies a complex elementary reflector H to a complex M-by-N matrix C, from either the left or the right. H is represented in the form H = I - tau * v * v**H where tau is a complex scalar and v is a complex vector. If tau = 0, then H is taken to be the unit matrix. To apply H**H (the conjugate transpose of H), supply conjg(tau) instead tau. H is a product of k elementary reflectors as returned by ZTZRZF.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_zlarzb | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| character, intent(in) | direct, | ||
| character, intent(in) | storev, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| complex(dp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(dp), dimension(ldt,*), intent(inout) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| complex(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| complex(dp), dimension(ldwork,*), intent(out) | work, | ||
| integer(ilp), intent(in) | ldwork ) |
ZLARZB: applies a complex block reflector H or its transpose H**H to a complex distributed M-by-N C from the left or the right. Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_zlarzt | ( | character, intent(in) | direct, |
| character, intent(in) | storev, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| complex(dp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| complex(dp), dimension(*), intent(in) | tau, | ||
| complex(dp), dimension(ldt,*), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt ) |
ZLARZT: forms the triangular factor T of a complex block reflector H of order > n, which is defined as a product of k elementary reflectors. If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular; If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular. If STOREV = 'C', the vector which defines the elementary reflector H(i) is stored in the i-th column of the array V, and H = I - V * T * V**H If STOREV = 'R', the vector which defines the elementary reflector H(i) is stored in the i-th row of the array V, and H = I - V**H * T * V Currently, only STOREV = 'R' and DIRECT = 'B' are supported.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_zlatrz | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | l, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(out) | tau, | ||
| complex(dp), dimension(*), intent(out) | work ) |
ZLATRZ: factors the M-by-(M+L) complex upper trapezoidal matrix [ A1 A2 ] = [ A(1:M,1:M) A(1:M,N-L+1:N) ] as ( R 0 ) * Z by means of unitary transformations, where Z is an (M+L)-by-(M+L) unitary matrix and, R and A1 are M-by-M upper triangular matrices.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_ztzrzf | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(out) | tau, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZTZRZF: reduces the M-by-N ( M<=N ) complex upper trapezoidal matrix A to upper triangular form by means of unitary transformations. The upper trapezoidal matrix A is factored as A = ( R 0 ) * Z, where Z is an N-by-N unitary matrix and R is an M-by-M upper triangular matrix.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_zunmr3 | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| complex(dp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(in) | tau, | ||
| complex(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(out) | info ) |
ZUNMR3: 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 ZTZRZF. Q is of order m if SIDE = 'L' and of order n if SIDE = 'R'.

| pure subroutine, public la_lapack_orthogonal_factors_rz::la_zunmrz | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | l, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(in) | tau, | ||
| complex(dp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZUNMRZ: 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 ZTZRZF. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.
