|
fortran-lapack
|
Hessenberg reduction: balancing, back-transformation, orthogonal factor generation. More...
Functions/Subroutines | |
| pure subroutine, public | la_sgebak (job, side, n, ilo, ihi, scale, m, v, ldv, info) |
| SGEBAK: forms the right or left eigenvectors of a real general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by SGEBAL. | |
| pure subroutine, public | la_dgebak (job, side, n, ilo, ihi, scale, m, v, ldv, info) |
| DGEBAK: forms the right or left eigenvectors of a real general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by DGEBAL. | |
| pure subroutine, public | la_qgebak (job, side, n, ilo, ihi, scale, m, v, ldv, info) |
| QGEBAK: forms the right or left eigenvectors of a real general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by QGEBAL. | |
| pure subroutine, public | la_sorghr (n, ilo, ihi, a, lda, tau, work, lwork, info) |
| SORGHR: generates a real orthogonal matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by SGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). | |
| pure subroutine, public | la_dorghr (n, ilo, ihi, a, lda, tau, work, lwork, info) |
| DORGHR: generates a real orthogonal matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). | |
| pure subroutine, public | la_qorghr (n, ilo, ihi, a, lda, tau, work, lwork, info) |
| QORGHR: generates a real orthogonal matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by QGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). | |
| pure subroutine, public | la_sormhr (side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) |
| SORMHR: 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 of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by SGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). | |
| pure subroutine, public | la_dormhr (side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) |
| DORMHR: 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 of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). | |
| pure subroutine, public | la_qormhr (side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) |
| QORMHR: 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 of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by QGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). | |
| pure subroutine, public | la_sgebal (job, n, a, lda, ilo, ihi, scale, info) |
| SGEBAL: balances a general real matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors. | |
| pure subroutine, public | la_dgebal (job, n, a, lda, ilo, ihi, scale, info) |
| DGEBAL: balances a general real matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors. | |
| pure subroutine, public | la_qgebal (job, n, a, lda, ilo, ihi, scale, info) |
| QGEBAL: balances a general real matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors. | |
| pure subroutine, public | la_sgehd2 (n, ilo, ihi, a, lda, tau, work, info) |
| SGEHD2: reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H . | |
| pure subroutine, public | la_dgehd2 (n, ilo, ihi, a, lda, tau, work, info) |
| DGEHD2: reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H . | |
| pure subroutine, public | la_qgehd2 (n, ilo, ihi, a, lda, tau, work, info) |
| QGEHD2: reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H . | |
| pure subroutine, public | la_slahr2 (n, k, nb, a, lda, tau, t, ldt, y, ldy) |
| SLAHR2: reduces the first NB columns of A real general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an orthogonal similarity transformation Q**T * A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T. This is an auxiliary routine called by SGEHRD. | |
| pure subroutine, public | la_dlahr2 (n, k, nb, a, lda, tau, t, ldt, y, ldy) |
| DLAHR2: reduces the first NB columns of A real general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an orthogonal similarity transformation Q**T * A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T. This is an auxiliary routine called by DGEHRD. | |
| pure subroutine, public | la_qlahr2 (n, k, nb, a, lda, tau, t, ldt, y, ldy) |
| QLAHR2: reduces the first NB columns of A real general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an orthogonal similarity transformation Q**T * A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T. This is an auxiliary routine called by QGEHRD. | |
| pure subroutine, public | la_sgehrd (n, ilo, ihi, a, lda, tau, work, lwork, info) |
| SGEHRD: reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H . | |
| pure subroutine, public | la_dgehrd (n, ilo, ihi, a, lda, tau, work, lwork, info) |
| DGEHRD: reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H . | |
| pure subroutine, public | la_qgehrd (n, ilo, ihi, a, lda, tau, work, lwork, info) |
| QGEHRD: reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H . | |
| pure subroutine, public | la_cgebak (job, side, n, ilo, ihi, scale, m, v, ldv, info) |
| CGEBAK: forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by CGEBAL. | |
| pure subroutine, public | la_zgebak (job, side, n, ilo, ihi, scale, m, v, ldv, info) |
| ZGEBAK: forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by ZGEBAL. | |
| pure subroutine, public | la_wgebak (job, side, n, ilo, ihi, scale, m, v, ldv, info) |
| WGEBAK: forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by WGEBAL. | |
| pure subroutine, public | la_cgebal (job, n, a, lda, ilo, ihi, scale, info) |
| CGEBAL: balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors. | |
| pure subroutine, public | la_zgebal (job, n, a, lda, ilo, ihi, scale, info) |
| ZGEBAL: balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors. | |
| pure subroutine, public | la_wgebal (job, n, a, lda, ilo, ihi, scale, info) |
| WGEBAL: balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors. | |
| pure subroutine, public | la_cgehd2 (n, ilo, ihi, a, lda, tau, work, info) |
| CGEHD2: reduces a complex general matrix A to upper Hessenberg form H by a unitary similarity transformation: Q**H * A * Q = H . | |
| pure subroutine, public | la_zgehd2 (n, ilo, ihi, a, lda, tau, work, info) |
| ZGEHD2: reduces a complex general matrix A to upper Hessenberg form H by a unitary similarity transformation: Q**H * A * Q = H . | |
| pure subroutine, public | la_wgehd2 (n, ilo, ihi, a, lda, tau, work, info) |
| WGEHD2: reduces a complex general matrix A to upper Hessenberg form H by a unitary similarity transformation: Q**H * A * Q = H . | |
| pure subroutine, public | la_clahr2 (n, k, nb, a, lda, tau, t, ldt, y, ldy) |
| CLAHR2: reduces the first NB columns of A complex general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an unitary similarity transformation Q**H * A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - V*T*v**H, and also the matrix Y = A * V * T. This is an auxiliary routine called by CGEHRD. | |
| pure subroutine, public | la_zlahr2 (n, k, nb, a, lda, tau, t, ldt, y, ldy) |
| ZLAHR2: reduces the first NB columns of A complex general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an unitary similarity transformation Q**H * A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - V*T*V**H, and also the matrix Y = A * V * T. This is an auxiliary routine called by ZGEHRD. | |
| pure subroutine, public | la_wlahr2 (n, k, nb, a, lda, tau, t, ldt, y, ldy) |
| WLAHR2: reduces the first NB columns of A complex general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an unitary similarity transformation Q**H * A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - V*T*V**H, and also the matrix Y = A * V * T. This is an auxiliary routine called by WGEHRD. | |
| pure subroutine, public | la_cunghr (n, ilo, ihi, a, lda, tau, work, lwork, info) |
| CUNGHR: generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). | |
| pure subroutine, public | la_zunghr (n, ilo, ihi, a, lda, tau, work, lwork, info) |
| ZUNGHR: generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by ZGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). | |
| pure subroutine, public | la_wunghr (n, ilo, ihi, a, lda, tau, work, lwork, info) |
| WUNGHR: generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by WGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). | |
| pure subroutine, public | la_cunmhr (side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) |
| CUNMHR: 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 of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). | |
| pure subroutine, public | la_zunmhr (side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) |
| ZUNMHR: 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 of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by ZGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). | |
| pure subroutine, public | la_wunmhr (side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info) |
| WUNMHR: 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 of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by WGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1). | |
| pure subroutine, public | la_cgehrd (n, ilo, ihi, a, lda, tau, work, lwork, info) |
| CGEHRD: reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q**H * A * Q = H . | |
| pure subroutine, public | la_zgehrd (n, ilo, ihi, a, lda, tau, work, lwork, info) |
| ZGEHRD: reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q**H * A * Q = H . | |
| pure subroutine, public | la_wgehrd (n, ilo, ihi, a, lda, tau, work, lwork, info) |
| WGEHRD: reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q**H * A * Q = H . | |
Hessenberg reduction: balancing, back-transformation, orthogonal factor generation.
| pure subroutine, public la_lapack_eigv_gen_hess::la_cgebak | ( | character, intent(in) | job, |
| character, intent(in) | side, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(sp), dimension(*), intent(in) | scale, | ||
| integer(ilp), intent(in) | m, | ||
| complex(sp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(out) | info ) |
CGEBAK: forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by CGEBAL.

| pure subroutine, public la_lapack_eigv_gen_hess::la_cgebal | ( | character, intent(in) | job, |
| integer(ilp), intent(in) | n, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | ilo, | ||
| integer(ilp), intent(out) | ihi, | ||
| real(sp), dimension(*), intent(out) | scale, | ||
| integer(ilp), intent(out) | info ) |
CGEBAL: balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.

| pure subroutine, public la_lapack_eigv_gen_hess::la_cgehd2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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(out) | info ) |
CGEHD2: reduces a complex general matrix A to upper Hessenberg form H by a unitary similarity transformation: Q**H * A * Q = H .

| pure subroutine, public la_lapack_eigv_gen_hess::la_cgehrd | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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 ) |
CGEHRD: reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q**H * A * Q = H .

| pure subroutine, public la_lapack_eigv_gen_hess::la_clahr2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | nb, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(nb), intent(out) | tau, | ||
| complex(sp), dimension(ldt,nb), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| complex(sp), dimension(ldy,nb), intent(out) | y, | ||
| integer(ilp), intent(in) | ldy ) |
CLAHR2: reduces the first NB columns of A complex general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an unitary similarity transformation Q**H * A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - V*T*v**H, and also the matrix Y = A * V * T. This is an auxiliary routine called by CGEHRD.

| pure subroutine, public la_lapack_eigv_gen_hess::la_cunghr | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(sp), dimension(*), intent(in) | tau, | ||
| complex(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
CUNGHR: generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

| pure subroutine, public la_lapack_eigv_gen_hess::la_cunmhr | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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 ) |
CUNMHR: 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 of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by CGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

| pure subroutine, public la_lapack_eigv_gen_hess::la_dgebak | ( | character, intent(in) | job, |
| character, intent(in) | side, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(dp), dimension(*), intent(in) | scale, | ||
| integer(ilp), intent(in) | m, | ||
| real(dp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(out) | info ) |
DGEBAK: forms the right or left eigenvectors of a real general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by DGEBAL.

| pure subroutine, public la_lapack_eigv_gen_hess::la_dgebal | ( | character, intent(in) | job, |
| integer(ilp), intent(in) | n, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | ilo, | ||
| integer(ilp), intent(out) | ihi, | ||
| real(dp), dimension(*), intent(out) | scale, | ||
| integer(ilp), intent(out) | info ) |
DGEBAL: balances a general real matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.

| pure subroutine, public la_lapack_eigv_gen_hess::la_dgehd2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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(out) | info ) |
DGEHD2: reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H .

| pure subroutine, public la_lapack_eigv_gen_hess::la_dgehrd | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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 ) |
DGEHRD: reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H .

| pure subroutine, public la_lapack_eigv_gen_hess::la_dlahr2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | nb, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(nb), intent(out) | tau, | ||
| real(dp), dimension(ldt,nb), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| real(dp), dimension(ldy,nb), intent(out) | y, | ||
| integer(ilp), intent(in) | ldy ) |
DLAHR2: reduces the first NB columns of A real general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an orthogonal similarity transformation Q**T * A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T. This is an auxiliary routine called by DGEHRD.

| pure subroutine, public la_lapack_eigv_gen_hess::la_dorghr | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(dp), dimension(*), intent(in) | tau, | ||
| real(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
DORGHR: generates a real orthogonal matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

| pure subroutine, public la_lapack_eigv_gen_hess::la_dormhr | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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 ) |
DORMHR: 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 of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by DGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

| pure subroutine, public la_lapack_eigv_gen_hess::la_qgebak | ( | character, intent(in) | job, |
| character, intent(in) | side, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(qp), dimension(*), intent(in) | scale, | ||
| integer(ilp), intent(in) | m, | ||
| real(qp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(out) | info ) |
QGEBAK: forms the right or left eigenvectors of a real general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by QGEBAL.

| pure subroutine, public la_lapack_eigv_gen_hess::la_qgebal | ( | character, intent(in) | job, |
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | ilo, | ||
| integer(ilp), intent(out) | ihi, | ||
| real(qp), dimension(*), intent(out) | scale, | ||
| integer(ilp), intent(out) | info ) |
QGEBAL: balances a general real matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.

| pure subroutine, public la_lapack_eigv_gen_hess::la_qgehd2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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(out) | info ) |
QGEHD2: reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H .

| pure subroutine, public la_lapack_eigv_gen_hess::la_qgehrd | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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 ) |
QGEHRD: reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H .

| pure subroutine, public la_lapack_eigv_gen_hess::la_qlahr2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | nb, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(nb), intent(out) | tau, | ||
| real(qp), dimension(ldt,nb), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| real(qp), dimension(ldy,nb), intent(out) | y, | ||
| integer(ilp), intent(in) | ldy ) |
QLAHR2: reduces the first NB columns of A real general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an orthogonal similarity transformation Q**T * A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T. This is an auxiliary routine called by QGEHRD.

| pure subroutine, public la_lapack_eigv_gen_hess::la_qorghr | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | tau, | ||
| real(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
QORGHR: generates a real orthogonal matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by QGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

| pure subroutine, public la_lapack_eigv_gen_hess::la_qormhr | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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 ) |
QORMHR: 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 of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by QGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

| pure subroutine, public la_lapack_eigv_gen_hess::la_sgebak | ( | character, intent(in) | job, |
| character, intent(in) | side, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(sp), dimension(*), intent(in) | scale, | ||
| integer(ilp), intent(in) | m, | ||
| real(sp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(out) | info ) |
SGEBAK: forms the right or left eigenvectors of a real general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by SGEBAL.

| pure subroutine, public la_lapack_eigv_gen_hess::la_sgebal | ( | character, intent(in) | job, |
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | ilo, | ||
| integer(ilp), intent(out) | ihi, | ||
| real(sp), dimension(*), intent(out) | scale, | ||
| integer(ilp), intent(out) | info ) |
SGEBAL: balances a general real matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.

| pure subroutine, public la_lapack_eigv_gen_hess::la_sgehd2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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(out) | info ) |
SGEHD2: reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H .

| pure subroutine, public la_lapack_eigv_gen_hess::la_sgehrd | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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 ) |
SGEHRD: reduces a real general matrix A to upper Hessenberg form H by an orthogonal similarity transformation: Q**T * A * Q = H .

| pure subroutine, public la_lapack_eigv_gen_hess::la_slahr2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | nb, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(nb), intent(out) | tau, | ||
| real(sp), dimension(ldt,nb), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| real(sp), dimension(ldy,nb), intent(out) | y, | ||
| integer(ilp), intent(in) | ldy ) |
SLAHR2: reduces the first NB columns of A real general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an orthogonal similarity transformation Q**T * A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T. This is an auxiliary routine called by SGEHRD.

| pure subroutine, public la_lapack_eigv_gen_hess::la_sorghr | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | tau, | ||
| real(sp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
SORGHR: generates a real orthogonal matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by SGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

| pure subroutine, public la_lapack_eigv_gen_hess::la_sormhr | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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 ) |
SORMHR: 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 of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by SGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

| pure subroutine, public la_lapack_eigv_gen_hess::la_wgebak | ( | character, intent(in) | job, |
| character, intent(in) | side, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(qp), dimension(*), intent(in) | scale, | ||
| integer(ilp), intent(in) | m, | ||
| complex(qp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(out) | info ) |
WGEBAK: forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by WGEBAL.

| pure subroutine, public la_lapack_eigv_gen_hess::la_wgebal | ( | character, intent(in) | job, |
| integer(ilp), intent(in) | n, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | ilo, | ||
| integer(ilp), intent(out) | ihi, | ||
| real(qp), dimension(*), intent(out) | scale, | ||
| integer(ilp), intent(out) | info ) |
WGEBAL: balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.

| pure subroutine, public la_lapack_eigv_gen_hess::la_wgehd2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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(out) | info ) |
WGEHD2: reduces a complex general matrix A to upper Hessenberg form H by a unitary similarity transformation: Q**H * A * Q = H .

| pure subroutine, public la_lapack_eigv_gen_hess::la_wgehrd | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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 ) |
WGEHRD: reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q**H * A * Q = H .

| pure subroutine, public la_lapack_eigv_gen_hess::la_wlahr2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | nb, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(nb), intent(out) | tau, | ||
| complex(qp), dimension(ldt,nb), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| complex(qp), dimension(ldy,nb), intent(out) | y, | ||
| integer(ilp), intent(in) | ldy ) |
WLAHR2: reduces the first NB columns of A complex general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an unitary similarity transformation Q**H * A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - V*T*V**H, and also the matrix Y = A * V * T. This is an auxiliary routine called by WGEHRD.

| pure subroutine, public la_lapack_eigv_gen_hess::la_wunghr | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(qp), dimension(*), intent(in) | tau, | ||
| complex(qp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
WUNGHR: generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by WGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

| pure subroutine, public la_lapack_eigv_gen_hess::la_wunmhr | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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 ) |
WUNMHR: 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 of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by WGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

| pure subroutine, public la_lapack_eigv_gen_hess::la_zgebak | ( | character, intent(in) | job, |
| character, intent(in) | side, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| real(dp), dimension(*), intent(in) | scale, | ||
| integer(ilp), intent(in) | m, | ||
| complex(dp), dimension(ldv,*), intent(inout) | v, | ||
| integer(ilp), intent(in) | ldv, | ||
| integer(ilp), intent(out) | info ) |
ZGEBAK: forms the right or left eigenvectors of a complex general matrix by backward transformation on the computed eigenvectors of the balanced matrix output by ZGEBAL.

| pure subroutine, public la_lapack_eigv_gen_hess::la_zgebal | ( | character, intent(in) | job, |
| integer(ilp), intent(in) | n, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| integer(ilp), intent(out) | ilo, | ||
| integer(ilp), intent(out) | ihi, | ||
| real(dp), dimension(*), intent(out) | scale, | ||
| integer(ilp), intent(out) | info ) |
ZGEBAL: balances a general complex matrix A. This involves, first, permuting A by a similarity transformation to isolate eigenvalues in the first 1 to ILO-1 and last IHI+1 to N elements on the diagonal; and second, applying a diagonal similarity transformation to rows and columns ILO to IHI to make the rows and columns as close in norm as possible. Both steps are optional. Balancing may reduce the 1-norm of the matrix, and improve the accuracy of the computed eigenvalues and/or eigenvectors.

| pure subroutine, public la_lapack_eigv_gen_hess::la_zgehd2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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(out) | info ) |
ZGEHD2: reduces a complex general matrix A to upper Hessenberg form H by a unitary similarity transformation: Q**H * A * Q = H .

| pure subroutine, public la_lapack_eigv_gen_hess::la_zgehrd | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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 ) |
ZGEHRD: reduces a complex general matrix A to upper Hessenberg form H by an unitary similarity transformation: Q**H * A * Q = H .

| pure subroutine, public la_lapack_eigv_gen_hess::la_zlahr2 | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | k, | ||
| integer(ilp), intent(in) | nb, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(nb), intent(out) | tau, | ||
| complex(dp), dimension(ldt,nb), intent(out) | t, | ||
| integer(ilp), intent(in) | ldt, | ||
| complex(dp), dimension(ldy,nb), intent(out) | y, | ||
| integer(ilp), intent(in) | ldy ) |
ZLAHR2: reduces the first NB columns of A complex general n-BY-(n-k+1) matrix A so that elements below the k-th subdiagonal are zero. The reduction is performed by an unitary similarity transformation Q**H * A * Q. The routine returns the matrices V and T which determine Q as a block reflector I - V*T*V**H, and also the matrix Y = A * V * T. This is an auxiliary routine called by ZGEHRD.

| pure subroutine, public la_lapack_eigv_gen_hess::la_zunghr | ( | integer(ilp), intent(in) | n, |
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| complex(dp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| complex(dp), dimension(*), intent(in) | tau, | ||
| complex(dp), dimension(*), intent(out) | work, | ||
| integer(ilp), intent(in) | lwork, | ||
| integer(ilp), intent(out) | info ) |
ZUNGHR: generates a complex unitary matrix Q which is defined as the product of IHI-ILO elementary reflectors of order N, as returned by ZGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).

| pure subroutine, public la_lapack_eigv_gen_hess::la_zunmhr | ( | character, intent(in) | side, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | ilo, | ||
| integer(ilp), intent(in) | ihi, | ||
| 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 ) |
ZUNMHR: 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 of order nq, with nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Q is defined as the product of IHI-ILO elementary reflectors, as returned by ZGEHRD: Q = H(ilo) H(ilo+1) . . . H(ihi-1).
