Provided by: liblapack-doc_3.10.1-2_all bug

NAME

       complexOTHERcomputational - complex

SYNOPSIS

   Functions
       subroutine cbbcsd (JOBU1, JOBU2, JOBV1T, JOBV2T, TRANS, M, P, Q, THETA, PHI, U1, LDU1, U2,
           LDU2, V1T, LDV1T, V2T, LDV2T, B11D, B11E, B12D, B12E, B21D, B21E, B22D, B22E, RWORK,
           LRWORK, INFO)
           CBBCSD
       subroutine cbdsqr (UPLO, N, NCVT, NRU, NCC, D, E, VT, LDVT, U, LDU, C, LDC, RWORK, INFO)
           CBDSQR
       subroutine cgghd3 (COMPQ, COMPZ, N, ILO, IHI, A, LDA, B, LDB, Q, LDQ, Z, LDZ, WORK, LWORK,
           INFO)
           CGGHD3
       subroutine cgghrd (COMPQ, COMPZ, N, ILO, IHI, A, LDA, B, LDB, Q, LDQ, Z, LDZ, INFO)
           CGGHRD
       subroutine cggqrf (N, M, P, A, LDA, TAUA, B, LDB, TAUB, WORK, LWORK, INFO)
           CGGQRF
       subroutine cggrqf (M, P, N, A, LDA, TAUA, B, LDB, TAUB, WORK, LWORK, INFO)
           CGGRQF
       subroutine cggsvp3 (JOBU, JOBV, JOBQ, M, P, N, A, LDA, B, LDB, TOLA, TOLB, K, L, U, LDU,
           V, LDV, Q, LDQ, IWORK, RWORK, TAU, WORK, LWORK, INFO)
           CGGSVP3
       subroutine cgsvj0 (JOBV, M, N, A, LDA, D, SVA, MV, V, LDV, EPS, SFMIN, TOL, NSWEEP, WORK,
           LWORK, INFO)
           CGSVJ0 pre-processor for the routine cgesvj.
       subroutine cgsvj1 (JOBV, M, N, N1, A, LDA, D, SVA, MV, V, LDV, EPS, SFMIN, TOL, NSWEEP,
           WORK, LWORK, INFO)
           CGSVJ1 pre-processor for the routine cgesvj, applies Jacobi rotations targeting only
           particular pivots.
       subroutine chbgst (VECT, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, X, LDX, WORK, RWORK, INFO)
           CHBGST
       subroutine chbtrd (VECT, UPLO, N, KD, AB, LDAB, D, E, Q, LDQ, WORK, INFO)
           CHBTRD
       subroutine chetrd_hb2st (STAGE1, VECT, UPLO, N, KD, AB, LDAB, D, E, HOUS, LHOUS, WORK,
           LWORK, INFO)
           CHETRD_HB2ST reduces a complex Hermitian band matrix A to real symmetric tridiagonal
           form T
       subroutine chfrk (TRANSR, UPLO, TRANS, N, K, ALPHA, A, LDA, BETA, C)
           CHFRK performs a Hermitian rank-k operation for matrix in RFP format.
       subroutine chpcon (UPLO, N, AP, IPIV, ANORM, RCOND, WORK, INFO)
           CHPCON
       subroutine chpgst (ITYPE, UPLO, N, AP, BP, INFO)
           CHPGST
       subroutine chprfs (UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, LDX, FERR, BERR, WORK, RWORK,
           INFO)
           CHPRFS
       subroutine chptrd (UPLO, N, AP, D, E, TAU, INFO)
           CHPTRD
       subroutine chptrf (UPLO, N, AP, IPIV, INFO)
           CHPTRF
       subroutine chptri (UPLO, N, AP, IPIV, WORK, INFO)
           CHPTRI
       subroutine chptrs (UPLO, N, NRHS, AP, IPIV, B, LDB, INFO)
           CHPTRS
       subroutine chsein (SIDE, EIGSRC, INITV, SELECT, N, H, LDH, W, VL, LDVL, VR, LDVR, MM, M,
           WORK, RWORK, IFAILL, IFAILR, INFO)
           CHSEIN
       subroutine chseqr (JOB, COMPZ, N, ILO, IHI, H, LDH, W, Z, LDZ, WORK, LWORK, INFO)
           CHSEQR
       subroutine cla_lin_berr (N, NZ, NRHS, RES, AYB, BERR)
           CLA_LIN_BERR computes a component-wise relative backward error.
       subroutine cla_wwaddw (N, X, Y, W)
           CLA_WWADDW adds a vector into a doubled-single vector.
       subroutine claed0 (QSIZ, N, D, E, Q, LDQ, QSTORE, LDQS, RWORK, IWORK, INFO)
           CLAED0 used by CSTEDC. Computes all eigenvalues and corresponding eigenvectors of an
           unreduced symmetric tridiagonal matrix using the divide and conquer method.
       subroutine claed7 (N, CUTPNT, QSIZ, TLVLS, CURLVL, CURPBM, D, Q, LDQ, RHO, INDXQ, QSTORE,
           QPTR, PRMPTR, PERM, GIVPTR, GIVCOL, GIVNUM, WORK, RWORK, IWORK, INFO)
           CLAED7 used by CSTEDC. Computes the updated eigensystem of a diagonal matrix after
           modification by a rank-one symmetric matrix. Used when the original matrix is dense.
       subroutine claed8 (K, N, QSIZ, Q, LDQ, D, RHO, CUTPNT, Z, DLAMDA, Q2, LDQ2, W, INDXP,
           INDX, INDXQ, PERM, GIVPTR, GIVCOL, GIVNUM, INFO)
           CLAED8 used by CSTEDC. Merges eigenvalues and deflates secular equation. Used when the
           original matrix is dense.
       subroutine clals0 (ICOMPQ, NL, NR, SQRE, NRHS, B, LDB, BX, LDBX, PERM, GIVPTR, GIVCOL,
           LDGCOL, GIVNUM, LDGNUM, POLES, DIFL, DIFR, Z, K, C, S, RWORK, INFO)
           CLALS0 applies back multiplying factors in solving the least squares problem using
           divide and conquer SVD approach. Used by sgelsd.
       subroutine clalsa (ICOMPQ, SMLSIZ, N, NRHS, B, LDB, BX, LDBX, U, LDU, VT, K, DIFL, DIFR,
           Z, POLES, GIVPTR, GIVCOL, LDGCOL, PERM, GIVNUM, C, S, RWORK, IWORK, INFO)
           CLALSA computes the SVD of the coefficient matrix in compact form. Used by sgelsd.
       subroutine clalsd (UPLO, SMLSIZ, N, NRHS, D, E, B, LDB, RCOND, RANK, WORK, RWORK, IWORK,
           INFO)
           CLALSD uses the singular value decomposition of A to solve the least squares problem.
       real function clanhf (NORM, TRANSR, UPLO, N, A, WORK)
           CLANHF returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,
           or the element of largest absolute value of a Hermitian matrix in RFP format.
       subroutine clarscl2 (M, N, D, X, LDX)
           CLARSCL2 performs reciprocal diagonal scaling on a vector.
       subroutine clarz (SIDE, M, N, L, V, INCV, TAU, C, LDC, WORK)
           CLARZ applies an elementary reflector (as returned by stzrzf) to a general matrix.
       subroutine clarzb (SIDE, TRANS, DIRECT, STOREV, M, N, K, L, V, LDV, T, LDT, C, LDC, WORK,
           LDWORK)
           CLARZB applies a block reflector or its conjugate-transpose to a general matrix.
       subroutine clarzt (DIRECT, STOREV, N, K, V, LDV, TAU, T, LDT)
           CLARZT forms the triangular factor T of a block reflector H = I - vtvH.
       subroutine clascl2 (M, N, D, X, LDX)
           CLASCL2 performs diagonal scaling on a vector.
       subroutine clatrz (M, N, L, A, LDA, TAU, WORK)
           CLATRZ factors an upper trapezoidal matrix by means of unitary transformations.
       subroutine cpbcon (UPLO, N, KD, AB, LDAB, ANORM, RCOND, WORK, RWORK, INFO)
           CPBCON
       subroutine cpbequ (UPLO, N, KD, AB, LDAB, S, SCOND, AMAX, INFO)
           CPBEQU
       subroutine cpbrfs (UPLO, N, KD, NRHS, AB, LDAB, AFB, LDAFB, B, LDB, X, LDX, FERR, BERR,
           WORK, RWORK, INFO)
           CPBRFS
       subroutine cpbstf (UPLO, N, KD, AB, LDAB, INFO)
           CPBSTF
       subroutine cpbtf2 (UPLO, N, KD, AB, LDAB, INFO)
           CPBTF2 computes the Cholesky factorization of a symmetric/Hermitian positive definite
           band matrix (unblocked algorithm).
       subroutine cpbtrf (UPLO, N, KD, AB, LDAB, INFO)
           CPBTRF
       subroutine cpbtrs (UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO)
           CPBTRS
       subroutine cpftrf (TRANSR, UPLO, N, A, INFO)
           CPFTRF
       subroutine cpftri (TRANSR, UPLO, N, A, INFO)
           CPFTRI
       subroutine cpftrs (TRANSR, UPLO, N, NRHS, A, B, LDB, INFO)
           CPFTRS
       subroutine cppcon (UPLO, N, AP, ANORM, RCOND, WORK, RWORK, INFO)
           CPPCON
       subroutine cppequ (UPLO, N, AP, S, SCOND, AMAX, INFO)
           CPPEQU
       subroutine cpprfs (UPLO, N, NRHS, AP, AFP, B, LDB, X, LDX, FERR, BERR, WORK, RWORK, INFO)
           CPPRFS
       subroutine cpptrf (UPLO, N, AP, INFO)
           CPPTRF
       subroutine cpptri (UPLO, N, AP, INFO)
           CPPTRI
       subroutine cpptrs (UPLO, N, NRHS, AP, B, LDB, INFO)
           CPPTRS
       subroutine cpstf2 (UPLO, N, A, LDA, PIV, RANK, TOL, WORK, INFO)
           CPSTF2 computes the Cholesky factorization with complete pivoting of complex Hermitian
           positive semidefinite matrix.
       subroutine cpstrf (UPLO, N, A, LDA, PIV, RANK, TOL, WORK, INFO)
           CPSTRF computes the Cholesky factorization with complete pivoting of complex Hermitian
           positive semidefinite matrix.
       subroutine cspcon (UPLO, N, AP, IPIV, ANORM, RCOND, WORK, INFO)
           CSPCON
       subroutine csprfs (UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, LDX, FERR, BERR, WORK, RWORK,
           INFO)
           CSPRFS
       subroutine csptrf (UPLO, N, AP, IPIV, INFO)
           CSPTRF
       subroutine csptri (UPLO, N, AP, IPIV, WORK, INFO)
           CSPTRI
       subroutine csptrs (UPLO, N, NRHS, AP, IPIV, B, LDB, INFO)
           CSPTRS
       subroutine cstedc (COMPZ, N, D, E, Z, LDZ, WORK, LWORK, RWORK, LRWORK, IWORK, LIWORK,
           INFO)
           CSTEDC
       subroutine cstegr (JOBZ, RANGE, N, D, E, VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, ISUPPZ,
           WORK, LWORK, IWORK, LIWORK, INFO)
           CSTEGR
       subroutine cstein (N, D, E, M, W, IBLOCK, ISPLIT, Z, LDZ, WORK, IWORK, IFAIL, INFO)
           CSTEIN
       subroutine cstemr (JOBZ, RANGE, N, D, E, VL, VU, IL, IU, M, W, Z, LDZ, NZC, ISUPPZ,
           TRYRAC, WORK, LWORK, IWORK, LIWORK, INFO)
           CSTEMR
       subroutine csteqr (COMPZ, N, D, E, Z, LDZ, WORK, INFO)
           CSTEQR
       subroutine ctbcon (NORM, UPLO, DIAG, N, KD, AB, LDAB, RCOND, WORK, RWORK, INFO)
           CTBCON
       subroutine ctbrfs (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, LDB, X, LDX, FERR, BERR,
           WORK, RWORK, INFO)
           CTBRFS
       subroutine ctbtrs (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, LDB, INFO)
           CTBTRS
       subroutine ctfsm (TRANSR, SIDE, UPLO, TRANS, DIAG, M, N, ALPHA, A, B, LDB)
           CTFSM solves a matrix equation (one operand is a triangular matrix in RFP format).
       subroutine ctftri (TRANSR, UPLO, DIAG, N, A, INFO)
           CTFTRI
       subroutine ctfttp (TRANSR, UPLO, N, ARF, AP, INFO)
           CTFTTP copies a triangular matrix from the rectangular full packed format (TF) to the
           standard packed format (TP).
       subroutine ctfttr (TRANSR, UPLO, N, ARF, A, LDA, INFO)
           CTFTTR copies a triangular matrix from the rectangular full packed format (TF) to the
           standard full format (TR).
       subroutine ctgsen (IJOB, WANTQ, WANTZ, SELECT, N, A, LDA, B, LDB, ALPHA, BETA, Q, LDQ, Z,
           LDZ, M, PL, PR, DIF, WORK, LWORK, IWORK, LIWORK, INFO)
           CTGSEN
       subroutine ctgsja (JOBU, JOBV, JOBQ, M, P, N, K, L, A, LDA, B, LDB, TOLA, TOLB, ALPHA,
           BETA, U, LDU, V, LDV, Q, LDQ, WORK, NCYCLE, INFO)
           CTGSJA
       subroutine ctgsna (JOB, HOWMNY, SELECT, N, A, LDA, B, LDB, VL, LDVL, VR, LDVR, S, DIF, MM,
           M, WORK, LWORK, IWORK, INFO)
           CTGSNA
       subroutine ctpcon (NORM, UPLO, DIAG, N, AP, RCOND, WORK, RWORK, INFO)
           CTPCON
       subroutine ctpmqrt (SIDE, TRANS, M, N, K, L, NB, V, LDV, T, LDT, A, LDA, B, LDB, WORK,
           INFO)
           CTPMQRT
       subroutine ctpqrt (M, N, L, NB, A, LDA, B, LDB, T, LDT, WORK, INFO)
           CTPQRT
       subroutine ctpqrt2 (M, N, L, A, LDA, B, LDB, T, LDT, INFO)
           CTPQRT2 computes a QR factorization of a real or complex 'triangular-pentagonal'
           matrix, which is composed of a triangular block and a pentagonal block, using the
           compact WY representation for Q.
       subroutine ctprfs (UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, X, LDX, FERR, BERR, WORK,
           RWORK, INFO)
           CTPRFS
       subroutine ctptri (UPLO, DIAG, N, AP, INFO)
           CTPTRI
       subroutine ctptrs (UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, INFO)
           CTPTRS
       subroutine ctpttf (TRANSR, UPLO, N, AP, ARF, INFO)
           CTPTTF copies a triangular matrix from the standard packed format (TP) to the
           rectangular full packed format (TF).
       subroutine ctpttr (UPLO, N, AP, A, LDA, INFO)
           CTPTTR copies a triangular matrix from the standard packed format (TP) to the standard
           full format (TR).
       subroutine ctrcon (NORM, UPLO, DIAG, N, A, LDA, RCOND, WORK, RWORK, INFO)
           CTRCON
       subroutine ctrevc (SIDE, HOWMNY, SELECT, N, T, LDT, VL, LDVL, VR, LDVR, MM, M, WORK,
           RWORK, INFO)
           CTREVC
       subroutine ctrevc3 (SIDE, HOWMNY, SELECT, N, T, LDT, VL, LDVL, VR, LDVR, MM, M, WORK,
           LWORK, RWORK, LRWORK, INFO)
           CTREVC3
       subroutine ctrexc (COMPQ, N, T, LDT, Q, LDQ, IFST, ILST, INFO)
           CTREXC
       subroutine ctrrfs (UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X, LDX, FERR, BERR, WORK,
           RWORK, INFO)
           CTRRFS
       subroutine ctrsen (JOB, COMPQ, SELECT, N, T, LDT, Q, LDQ, W, M, S, SEP, WORK, LWORK, INFO)
           CTRSEN
       subroutine ctrsna (JOB, HOWMNY, SELECT, N, T, LDT, VL, LDVL, VR, LDVR, S, SEP, MM, M,
           WORK, LDWORK, RWORK, INFO)
           CTRSNA
       subroutine ctrti2 (UPLO, DIAG, N, A, LDA, INFO)
           CTRTI2 computes the inverse of a triangular matrix (unblocked algorithm).
       subroutine ctrtri (UPLO, DIAG, N, A, LDA, INFO)
           CTRTRI
       subroutine ctrtrs (UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, INFO)
           CTRTRS
       subroutine ctrttf (TRANSR, UPLO, N, A, LDA, ARF, INFO)
           CTRTTF copies a triangular matrix from the standard full format (TR) to the
           rectangular full packed format (TF).
       subroutine ctrttp (UPLO, N, A, LDA, AP, INFO)
           CTRTTP copies a triangular matrix from the standard full format (TR) to the standard
           packed format (TP).
       subroutine ctzrzf (M, N, A, LDA, TAU, WORK, LWORK, INFO)
           CTZRZF
       subroutine cunbdb (TRANS, SIGNS, M, P, Q, X11, LDX11, X12, LDX12, X21, LDX21, X22, LDX22,
           THETA, PHI, TAUP1, TAUP2, TAUQ1, TAUQ2, WORK, LWORK, INFO)
           CUNBDB
       subroutine cunbdb1 (M, P, Q, X11, LDX11, X21, LDX21, THETA, PHI, TAUP1, TAUP2, TAUQ1,
           WORK, LWORK, INFO)
           CUNBDB1
       subroutine cunbdb2 (M, P, Q, X11, LDX11, X21, LDX21, THETA, PHI, TAUP1, TAUP2, TAUQ1,
           WORK, LWORK, INFO)
           CUNBDB2
       subroutine cunbdb3 (M, P, Q, X11, LDX11, X21, LDX21, THETA, PHI, TAUP1, TAUP2, TAUQ1,
           WORK, LWORK, INFO)
           CUNBDB3
       subroutine cunbdb4 (M, P, Q, X11, LDX11, X21, LDX21, THETA, PHI, TAUP1, TAUP2, TAUQ1,
           PHANTOM, WORK, LWORK, INFO)
           CUNBDB4
       subroutine cunbdb5 (M1, M2, N, X1, INCX1, X2, INCX2, Q1, LDQ1, Q2, LDQ2, WORK, LWORK,
           INFO)
           CUNBDB5
       subroutine cunbdb6 (M1, M2, N, X1, INCX1, X2, INCX2, Q1, LDQ1, Q2, LDQ2, WORK, LWORK,
           INFO)
           CUNBDB6
       recursive subroutine cuncsd (JOBU1, JOBU2, JOBV1T, JOBV2T, TRANS, SIGNS, M, P, Q, X11,
           LDX11, X12, LDX12, X21, LDX21, X22, LDX22, THETA, U1, LDU1, U2, LDU2, V1T, LDV1T, V2T,
           LDV2T, WORK, LWORK, RWORK, LRWORK, IWORK, INFO)
           CUNCSD
       subroutine cuncsd2by1 (JOBU1, JOBU2, JOBV1T, M, P, Q, X11, LDX11, X21, LDX21, THETA, U1,
           LDU1, U2, LDU2, V1T, LDV1T, WORK, LWORK, RWORK, LRWORK, IWORK, INFO)
           CUNCSD2BY1
       subroutine cung2l (M, N, K, A, LDA, TAU, WORK, INFO)
           CUNG2L generates all or part of the unitary matrix Q from a QL factorization
           determined by cgeqlf (unblocked algorithm).
       subroutine cung2r (M, N, K, A, LDA, TAU, WORK, INFO)
           CUNG2R
       subroutine cunghr (N, ILO, IHI, A, LDA, TAU, WORK, LWORK, INFO)
           CUNGHR
       subroutine cungl2 (M, N, K, A, LDA, TAU, WORK, INFO)
           CUNGL2 generates all or part of the unitary matrix Q from an LQ factorization
           determined by cgelqf (unblocked algorithm).
       subroutine cunglq (M, N, K, A, LDA, TAU, WORK, LWORK, INFO)
           CUNGLQ
       subroutine cungql (M, N, K, A, LDA, TAU, WORK, LWORK, INFO)
           CUNGQL
       subroutine cungqr (M, N, K, A, LDA, TAU, WORK, LWORK, INFO)
           CUNGQR
       subroutine cungr2 (M, N, K, A, LDA, TAU, WORK, INFO)
           CUNGR2 generates all or part of the unitary matrix Q from an RQ factorization
           determined by cgerqf (unblocked algorithm).
       subroutine cungrq (M, N, K, A, LDA, TAU, WORK, LWORK, INFO)
           CUNGRQ
       subroutine cungtr (UPLO, N, A, LDA, TAU, WORK, LWORK, INFO)
           CUNGTR
       subroutine cungtsqr (M, N, MB, NB, A, LDA, T, LDT, WORK, LWORK, INFO)
           CUNGTSQR
       subroutine cungtsqr_row (M, N, MB, NB, A, LDA, T, LDT, WORK, LWORK, INFO)
           CUNGTSQR_ROW
       subroutine cunhr_col (M, N, NB, A, LDA, T, LDT, D, INFO)
           CUNHR_COL
       subroutine cunm22 (SIDE, TRANS, M, N, N1, N2, Q, LDQ, C, LDC, WORK, LWORK, INFO)
           CUNM22 multiplies a general matrix by a banded unitary matrix.
       subroutine cunm2l (SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, INFO)
           CUNM2L multiplies a general matrix by the unitary matrix from a QL factorization
           determined by cgeqlf (unblocked algorithm).
       subroutine cunm2r (SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, INFO)
           CUNM2R multiplies a general matrix by the unitary matrix from a QR factorization
           determined by cgeqrf (unblocked algorithm).
       subroutine cunmbr (VECT, SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
           CUNMBR
       subroutine cunmhr (SIDE, TRANS, M, N, ILO, IHI, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
           CUNMHR
       subroutine cunml2 (SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, INFO)
           CUNML2 multiplies a general matrix by the unitary matrix from a LQ factorization
           determined by cgelqf (unblocked algorithm).
       subroutine cunmlq (SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
           CUNMLQ
       subroutine cunmql (SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
           CUNMQL
       subroutine cunmqr (SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
           CUNMQR
       subroutine cunmr2 (SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, INFO)
           CUNMR2 multiplies a general matrix by the unitary matrix from a RQ factorization
           determined by cgerqf (unblocked algorithm).
       subroutine cunmr3 (SIDE, TRANS, M, N, K, L, A, LDA, TAU, C, LDC, WORK, INFO)
           CUNMR3 multiplies a general matrix by the unitary matrix from a RZ factorization
           determined by ctzrzf (unblocked algorithm).
       subroutine cunmrq (SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
           CUNMRQ
       subroutine cunmrz (SIDE, TRANS, M, N, K, L, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
           CUNMRZ
       subroutine cunmtr (SIDE, UPLO, TRANS, M, N, A, LDA, TAU, C, LDC, WORK, LWORK, INFO)
           CUNMTR
       subroutine cupgtr (UPLO, N, AP, TAU, Q, LDQ, WORK, INFO)
           CUPGTR
       subroutine cupmtr (SIDE, UPLO, TRANS, M, N, AP, TAU, C, LDC, WORK, INFO)
           CUPMTR
       subroutine dorm22 (SIDE, TRANS, M, N, N1, N2, Q, LDQ, C, LDC, WORK, LWORK, INFO)
           DORM22 multiplies a general matrix by a banded orthogonal matrix.
       subroutine sorm22 (SIDE, TRANS, M, N, N1, N2, Q, LDQ, C, LDC, WORK, LWORK, INFO)
           SORM22 multiplies a general matrix by a banded orthogonal matrix.
       subroutine zunm22 (SIDE, TRANS, M, N, N1, N2, Q, LDQ, C, LDC, WORK, LWORK, INFO)
           ZUNM22 multiplies a general matrix by a banded unitary matrix.

Detailed Description

       This is the group of complex other Computational routines

Function Documentation

   subroutine cbbcsd (character JOBU1, character JOBU2, character JOBV1T, character JOBV2T,
       character TRANS, integer M, integer P, integer Q, real, dimension( * ) THETA, real,
       dimension( * ) PHI, complex, dimension( ldu1, * ) U1, integer LDU1, complex, dimension(
       ldu2, * ) U2, integer LDU2, complex, dimension( ldv1t, * ) V1T, integer LDV1T, complex,
       dimension( ldv2t, * ) V2T, integer LDV2T, real, dimension( * ) B11D, real, dimension( * )
       B11E, real, dimension( * ) B12D, real, dimension( * ) B12E, real, dimension( * ) B21D,
       real, dimension( * ) B21E, real, dimension( * ) B22D, real, dimension( * ) B22E, real,
       dimension( * ) RWORK, integer LRWORK, integer INFO)
       CBBCSD

       Purpose:

            CBBCSD computes the CS decomposition of a unitary matrix in
            bidiagonal-block form,

                [ B11 | B12 0  0 ]
                [  0  |  0 -I  0 ]
            X = [----------------]
                [ B21 | B22 0  0 ]
                [  0  |  0  0  I ]

                                          [  C | -S  0  0 ]
                              [ U1 |    ] [  0 |  0 -I  0 ] [ V1 |    ]**H
                            = [---------] [---------------] [---------]   .
                              [    | U2 ] [  S |  C  0  0 ] [    | V2 ]
                                          [  0 |  0  0  I ]

            X is M-by-M, its top-left block is P-by-Q, and Q must be no larger
            than P, M-P, or M-Q. (If Q is not the smallest index, then X must be
            transposed and/or permuted. This can be done in constant time using
            the TRANS and SIGNS options. See CUNCSD for details.)

            The bidiagonal matrices B11, B12, B21, and B22 are represented
            implicitly by angles THETA(1:Q) and PHI(1:Q-1).

            The unitary matrices U1, U2, V1T, and V2T are input/output.
            The input matrices are pre- or post-multiplied by the appropriate
            singular vector matrices.

       Parameters
           JOBU1

                     JOBU1 is CHARACTER
                     = 'Y':      U1 is updated;
                     otherwise:  U1 is not updated.

           JOBU2

                     JOBU2 is CHARACTER
                     = 'Y':      U2 is updated;
                     otherwise:  U2 is not updated.

           JOBV1T

                     JOBV1T is CHARACTER
                     = 'Y':      V1T is updated;
                     otherwise:  V1T is not updated.

           JOBV2T

                     JOBV2T is CHARACTER
                     = 'Y':      V2T is updated;
                     otherwise:  V2T is not updated.

           TRANS

                     TRANS is CHARACTER
                     = 'T':      X, U1, U2, V1T, and V2T are stored in row-major
                                 order;
                     otherwise:  X, U1, U2, V1T, and V2T are stored in column-
                                 major order.

           M

                     M is INTEGER
                     The number of rows and columns in X, the unitary matrix in
                     bidiagonal-block form.

           P

                     P is INTEGER
                     The number of rows in the top-left block of X. 0 <= P <= M.

           Q

                     Q is INTEGER
                     The number of columns in the top-left block of X.
                     0 <= Q <= MIN(P,M-P,M-Q).

           THETA

                     THETA is REAL array, dimension (Q)
                     On entry, the angles THETA(1),...,THETA(Q) that, along with
                     PHI(1), ...,PHI(Q-1), define the matrix in bidiagonal-block
                     form. On exit, the angles whose cosines and sines define the
                     diagonal blocks in the CS decomposition.

           PHI

                     PHI is REAL array, dimension (Q-1)
                     The angles PHI(1),...,PHI(Q-1) that, along with THETA(1),...,
                     THETA(Q), define the matrix in bidiagonal-block form.

           U1

                     U1 is COMPLEX array, dimension (LDU1,P)
                     On entry, a P-by-P matrix. On exit, U1 is postmultiplied
                     by the left singular vector matrix common to [ B11 ; 0 ] and
                     [ B12 0 0 ; 0 -I 0 0 ].

           LDU1

                     LDU1 is INTEGER
                     The leading dimension of the array U1, LDU1 >= MAX(1,P).

           U2

                     U2 is COMPLEX array, dimension (LDU2,M-P)
                     On entry, an (M-P)-by-(M-P) matrix. On exit, U2 is
                     postmultiplied by the left singular vector matrix common to
                     [ B21 ; 0 ] and [ B22 0 0 ; 0 0 I ].

           LDU2

                     LDU2 is INTEGER
                     The leading dimension of the array U2, LDU2 >= MAX(1,M-P).

           V1T

                     V1T is COMPLEX array, dimension (LDV1T,Q)
                     On entry, a Q-by-Q matrix. On exit, V1T is premultiplied
                     by the conjugate transpose of the right singular vector
                     matrix common to [ B11 ; 0 ] and [ B21 ; 0 ].

           LDV1T

                     LDV1T is INTEGER
                     The leading dimension of the array V1T, LDV1T >= MAX(1,Q).

           V2T

                     V2T is COMPLEX array, dimension (LDV2T,M-Q)
                     On entry, an (M-Q)-by-(M-Q) matrix. On exit, V2T is
                     premultiplied by the conjugate transpose of the right
                     singular vector matrix common to [ B12 0 0 ; 0 -I 0 ] and
                     [ B22 0 0 ; 0 0 I ].

           LDV2T

                     LDV2T is INTEGER
                     The leading dimension of the array V2T, LDV2T >= MAX(1,M-Q).

           B11D

                     B11D is REAL array, dimension (Q)
                     When CBBCSD converges, B11D contains the cosines of THETA(1),
                     ..., THETA(Q). If CBBCSD fails to converge, then B11D
                     contains the diagonal of the partially reduced top-left
                     block.

           B11E

                     B11E is REAL array, dimension (Q-1)
                     When CBBCSD converges, B11E contains zeros. If CBBCSD fails
                     to converge, then B11E contains the superdiagonal of the
                     partially reduced top-left block.

           B12D

                     B12D is REAL array, dimension (Q)
                     When CBBCSD converges, B12D contains the negative sines of
                     THETA(1), ..., THETA(Q). If CBBCSD fails to converge, then
                     B12D contains the diagonal of the partially reduced top-right
                     block.

           B12E

                     B12E is REAL array, dimension (Q-1)
                     When CBBCSD converges, B12E contains zeros. If CBBCSD fails
                     to converge, then B12E contains the subdiagonal of the
                     partially reduced top-right block.

           B21D

                     B21D is REAL array, dimension (Q)
                     When CBBCSD converges, B21D contains the negative sines of
                     THETA(1), ..., THETA(Q). If CBBCSD fails to converge, then
                     B21D contains the diagonal of the partially reduced bottom-left
                     block.

           B21E

                     B21E is REAL array, dimension (Q-1)
                     When CBBCSD converges, B21E contains zeros. If CBBCSD fails
                     to converge, then B21E contains the subdiagonal of the
                     partially reduced bottom-left block.

           B22D

                     B22D is REAL array, dimension (Q)
                     When CBBCSD converges, B22D contains the negative sines of
                     THETA(1), ..., THETA(Q). If CBBCSD fails to converge, then
                     B22D contains the diagonal of the partially reduced bottom-right
                     block.

           B22E

                     B22E is REAL array, dimension (Q-1)
                     When CBBCSD converges, B22E contains zeros. If CBBCSD fails
                     to converge, then B22E contains the subdiagonal of the
                     partially reduced bottom-right block.

           RWORK

                     RWORK is REAL array, dimension (MAX(1,LRWORK))
                     On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.

           LRWORK

                     LRWORK is INTEGER
                     The dimension of the array RWORK. LRWORK >= MAX(1,8*Q).

                     If LRWORK = -1, then a workspace query is assumed; the
                     routine only calculates the optimal size of the RWORK array,
                     returns this value as the first entry of the work array, and
                     no error message related to LRWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  if CBBCSD did not converge, INFO specifies the number
                           of nonzero entries in PHI, and B11D, B11E, etc.,
                           contain the partially reduced matrix.

       Internal Parameters:

             TOLMUL  REAL, default = MAX(10,MIN(100,EPS**(-1/8)))
                     TOLMUL controls the convergence criterion of the QR loop.
                     Angles THETA(i), PHI(i) are rounded to 0 or PI/2 when they
                     are within TOLMUL*EPS of either bound.

       References:
           [1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms,
           50(1):33-65, 2009.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cbdsqr (character UPLO, integer N, integer NCVT, integer NRU, integer NCC, real,
       dimension( * ) D, real, dimension( * ) E, complex, dimension( ldvt, * ) VT, integer LDVT,
       complex, dimension( ldu, * ) U, integer LDU, complex, dimension( ldc, * ) C, integer LDC,
       real, dimension( * ) RWORK, integer INFO)
       CBDSQR

       Purpose:

            CBDSQR computes the singular values and, optionally, the right and/or
            left singular vectors from the singular value decomposition (SVD) of
            a real N-by-N (upper or lower) bidiagonal matrix B using the implicit
            zero-shift QR algorithm.  The SVD of B has the form

               B = Q * S * P**H

            where S is the diagonal matrix of singular values, Q is an orthogonal
            matrix of left singular vectors, and P is an orthogonal matrix of
            right singular vectors.  If left singular vectors are requested, this
            subroutine actually returns U*Q instead of Q, and, if right singular
            vectors are requested, this subroutine returns P**H*VT instead of
            P**H, for given complex input matrices U and VT.  When U and VT are
            the unitary matrices that reduce a general matrix A to bidiagonal
            form: A = U*B*VT, as computed by CGEBRD, then

               A = (U*Q) * S * (P**H*VT)

            is the SVD of A.  Optionally, the subroutine may also compute Q**H*C
            for a given complex input matrix C.

            See "Computing  Small Singular Values of Bidiagonal Matrices With
            Guaranteed High Relative Accuracy," by J. Demmel and W. Kahan,
            LAPACK Working Note #3 (or SIAM J. Sci. Statist. Comput. vol. 11,
            no. 5, pp. 873-912, Sept 1990) and
            "Accurate singular values and differential qd algorithms," by
            B. Parlett and V. Fernando, Technical Report CPAM-554, Mathematics
            Department, University of California at Berkeley, July 1992
            for a detailed description of the algorithm.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  B is upper bidiagonal;
                     = 'L':  B is lower bidiagonal.

           N

                     N is INTEGER
                     The order of the matrix B.  N >= 0.

           NCVT

                     NCVT is INTEGER
                     The number of columns of the matrix VT. NCVT >= 0.

           NRU

                     NRU is INTEGER
                     The number of rows of the matrix U. NRU >= 0.

           NCC

                     NCC is INTEGER
                     The number of columns of the matrix C. NCC >= 0.

           D

                     D is REAL array, dimension (N)
                     On entry, the n diagonal elements of the bidiagonal matrix B.
                     On exit, if INFO=0, the singular values of B in decreasing
                     order.

           E

                     E is REAL array, dimension (N-1)
                     On entry, the N-1 offdiagonal elements of the bidiagonal
                     matrix B.
                     On exit, if INFO = 0, E is destroyed; if INFO > 0, D and E
                     will contain the diagonal and superdiagonal elements of a
                     bidiagonal matrix orthogonally equivalent to the one given
                     as input.

           VT

                     VT is COMPLEX array, dimension (LDVT, NCVT)
                     On entry, an N-by-NCVT matrix VT.
                     On exit, VT is overwritten by P**H * VT.
                     Not referenced if NCVT = 0.

           LDVT

                     LDVT is INTEGER
                     The leading dimension of the array VT.
                     LDVT >= max(1,N) if NCVT > 0; LDVT >= 1 if NCVT = 0.

           U

                     U is COMPLEX array, dimension (LDU, N)
                     On entry, an NRU-by-N matrix U.
                     On exit, U is overwritten by U * Q.
                     Not referenced if NRU = 0.

           LDU

                     LDU is INTEGER
                     The leading dimension of the array U.  LDU >= max(1,NRU).

           C

                     C is COMPLEX array, dimension (LDC, NCC)
                     On entry, an N-by-NCC matrix C.
                     On exit, C is overwritten by Q**H * C.
                     Not referenced if NCC = 0.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C.
                     LDC >= max(1,N) if NCC > 0; LDC >=1 if NCC = 0.

           RWORK

                     RWORK is REAL array, dimension (4*N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  If INFO = -i, the i-th argument had an illegal value
                     > 0:  the algorithm did not converge; D and E contain the
                           elements of a bidiagonal matrix which is orthogonally
                           similar to the input matrix B;  if INFO = i, i
                           elements of E have not converged to zero.

       Internal Parameters:

             TOLMUL  REAL, default = max(10,min(100,EPS**(-1/8)))
                     TOLMUL controls the convergence criterion of the QR loop.
                     If it is positive, TOLMUL*EPS is the desired relative
                        precision in the computed singular values.
                     If it is negative, abs(TOLMUL*EPS*sigma_max) is the
                        desired absolute accuracy in the computed singular
                        values (corresponds to relative accuracy
                        abs(TOLMUL*EPS) in the largest singular value.
                     abs(TOLMUL) should be between 1 and 1/EPS, and preferably
                        between 10 (for fast convergence) and .1/EPS
                        (for there to be some accuracy in the results).
                     Default is to lose at either one eighth or 2 of the
                        available decimal digits in each computed singular value
                        (whichever is smaller).

             MAXITR  INTEGER, default = 6
                     MAXITR controls the maximum number of passes of the
                     algorithm through its inner loop. The algorithms stops
                     (and so fails to converge) if the number of passes
                     through the inner loop exceeds MAXITR*N**2.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cgghd3 (character COMPQ, character COMPZ, integer N, integer ILO, integer IHI,
       complex, dimension( lda, * ) A, integer LDA, complex, dimension( ldb, * ) B, integer LDB,
       complex, dimension( ldq, * ) Q, integer LDQ, complex, dimension( ldz, * ) Z, integer LDZ,
       complex, dimension( * ) WORK, integer LWORK, integer INFO)
       CGGHD3

       Purpose:

            CGGHD3 reduces a pair of complex matrices (A,B) to generalized upper
            Hessenberg form using unitary transformations, where A is a
            general matrix and B is upper triangular.  The form of the
            generalized eigenvalue problem is
               A*x = lambda*B*x,
            and B is typically made upper triangular by computing its QR
            factorization and moving the unitary matrix Q to the left side
            of the equation.

            This subroutine simultaneously reduces A to a Hessenberg matrix H:
               Q**H*A*Z = H
            and transforms B to another upper triangular matrix T:
               Q**H*B*Z = T
            in order to reduce the problem to its standard form
               H*y = lambda*T*y
            where y = Z**H*x.

            The unitary matrices Q and Z are determined as products of Givens
            rotations.  They may either be formed explicitly, or they may be
            postmultiplied into input matrices Q1 and Z1, so that

                 Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H

                 Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H

            If Q1 is the unitary matrix from the QR factorization of B in the
            original equation A*x = lambda*B*x, then CGGHD3 reduces the original
            problem to generalized Hessenberg form.

            This is a blocked variant of CGGHRD, using matrix-matrix
            multiplications for parts of the computation to enhance performance.

       Parameters
           COMPQ

                     COMPQ is CHARACTER*1
                     = 'N': do not compute Q;
                     = 'I': Q is initialized to the unit matrix, and the
                            unitary matrix Q is returned;
                     = 'V': Q must contain a unitary matrix Q1 on entry,
                            and the product Q1*Q is returned.

           COMPZ

                     COMPZ is CHARACTER*1
                     = 'N': do not compute Z;
                     = 'I': Z is initialized to the unit matrix, and the
                            unitary matrix Z is returned;
                     = 'V': Z must contain a unitary matrix Z1 on entry,
                            and the product Z1*Z is returned.

           N

                     N is INTEGER
                     The order of the matrices A and B.  N >= 0.

           ILO

                     ILO is INTEGER

           IHI

                     IHI is INTEGER

                     ILO and IHI mark the rows and columns of A which are to be
                     reduced.  It is assumed that A is already upper triangular
                     in rows and columns 1:ILO-1 and IHI+1:N.  ILO and IHI are
                     normally set by a previous call to CGGBAL; otherwise they
                     should be set to 1 and N respectively.
                     1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.

           A

                     A is COMPLEX array, dimension (LDA, N)
                     On entry, the N-by-N general matrix to be reduced.
                     On exit, the upper triangle and the first subdiagonal of A
                     are overwritten with the upper Hessenberg matrix H, and the
                     rest is set to zero.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           B

                     B is COMPLEX array, dimension (LDB, N)
                     On entry, the N-by-N upper triangular matrix B.
                     On exit, the upper triangular matrix T = Q**H B Z.  The
                     elements below the diagonal are set to zero.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           Q

                     Q is COMPLEX array, dimension (LDQ, N)
                     On entry, if COMPQ = 'V', the unitary matrix Q1, typically
                     from the QR factorization of B.
                     On exit, if COMPQ='I', the unitary matrix Q, and if
                     COMPQ = 'V', the product Q1*Q.
                     Not referenced if COMPQ='N'.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q.
                     LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise.

           Z

                     Z is COMPLEX array, dimension (LDZ, N)
                     On entry, if COMPZ = 'V', the unitary matrix Z1.
                     On exit, if COMPZ='I', the unitary matrix Z, and if
                     COMPZ = 'V', the product Z1*Z.
                     Not referenced if COMPZ='N'.

           LDZ

                     LDZ is INTEGER
                     The leading dimension of the array Z.
                     LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise.

           WORK

                     WORK is COMPLEX array, dimension (LWORK)
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The length of the array WORK.  LWORK >= 1.
                     For optimum performance LWORK >= 6*N*NB, where NB is the
                     optimal blocksize.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             This routine reduces A to Hessenberg form and maintains B in triangular form
             using a blocked variant of Moler and Stewart's original algorithm,
             as described by Kagstrom, Kressner, Quintana-Orti, and Quintana-Orti
             (BIT 2008).

   subroutine cgghrd (character COMPQ, character COMPZ, integer N, integer ILO, integer IHI,
       complex, dimension( lda, * ) A, integer LDA, complex, dimension( ldb, * ) B, integer LDB,
       complex, dimension( ldq, * ) Q, integer LDQ, complex, dimension( ldz, * ) Z, integer LDZ,
       integer INFO)
       CGGHRD

       Purpose:

            CGGHRD reduces a pair of complex matrices (A,B) to generalized upper
            Hessenberg form using unitary transformations, where A is a
            general matrix and B is upper triangular.  The form of the generalized
            eigenvalue problem is
               A*x = lambda*B*x,
            and B is typically made upper triangular by computing its QR
            factorization and moving the unitary matrix Q to the left side
            of the equation.

            This subroutine simultaneously reduces A to a Hessenberg matrix H:
               Q**H*A*Z = H
            and transforms B to another upper triangular matrix T:
               Q**H*B*Z = T
            in order to reduce the problem to its standard form
               H*y = lambda*T*y
            where y = Z**H*x.

            The unitary matrices Q and Z are determined as products of Givens
            rotations.  They may either be formed explicitly, or they may be
            postmultiplied into input matrices Q1 and Z1, so that
                 Q1 * A * Z1**H = (Q1*Q) * H * (Z1*Z)**H
                 Q1 * B * Z1**H = (Q1*Q) * T * (Z1*Z)**H
            If Q1 is the unitary matrix from the QR factorization of B in the
            original equation A*x = lambda*B*x, then CGGHRD reduces the original
            problem to generalized Hessenberg form.

       Parameters
           COMPQ

                     COMPQ is CHARACTER*1
                     = 'N': do not compute Q;
                     = 'I': Q is initialized to the unit matrix, and the
                            unitary matrix Q is returned;
                     = 'V': Q must contain a unitary matrix Q1 on entry,
                            and the product Q1*Q is returned.

           COMPZ

                     COMPZ is CHARACTER*1
                     = 'N': do not compute Z;
                     = 'I': Z is initialized to the unit matrix, and the
                            unitary matrix Z is returned;
                     = 'V': Z must contain a unitary matrix Z1 on entry,
                            and the product Z1*Z is returned.

           N

                     N is INTEGER
                     The order of the matrices A and B.  N >= 0.

           ILO

                     ILO is INTEGER

           IHI

                     IHI is INTEGER

                     ILO and IHI mark the rows and columns of A which are to be
                     reduced.  It is assumed that A is already upper triangular
                     in rows and columns 1:ILO-1 and IHI+1:N.  ILO and IHI are
                     normally set by a previous call to CGGBAL; otherwise they
                     should be set to 1 and N respectively.
                     1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.

           A

                     A is COMPLEX array, dimension (LDA, N)
                     On entry, the N-by-N general matrix to be reduced.
                     On exit, the upper triangle and the first subdiagonal of A
                     are overwritten with the upper Hessenberg matrix H, and the
                     rest is set to zero.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           B

                     B is COMPLEX array, dimension (LDB, N)
                     On entry, the N-by-N upper triangular matrix B.
                     On exit, the upper triangular matrix T = Q**H B Z.  The
                     elements below the diagonal are set to zero.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           Q

                     Q is COMPLEX array, dimension (LDQ, N)
                     On entry, if COMPQ = 'V', the unitary matrix Q1, typically
                     from the QR factorization of B.
                     On exit, if COMPQ='I', the unitary matrix Q, and if
                     COMPQ = 'V', the product Q1*Q.
                     Not referenced if COMPQ='N'.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q.
                     LDQ >= N if COMPQ='V' or 'I'; LDQ >= 1 otherwise.

           Z

                     Z is COMPLEX array, dimension (LDZ, N)
                     On entry, if COMPZ = 'V', the unitary matrix Z1.
                     On exit, if COMPZ='I', the unitary matrix Z, and if
                     COMPZ = 'V', the product Z1*Z.
                     Not referenced if COMPZ='N'.

           LDZ

                     LDZ is INTEGER
                     The leading dimension of the array Z.
                     LDZ >= N if COMPZ='V' or 'I'; LDZ >= 1 otherwise.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             This routine reduces A to Hessenberg and B to triangular form by
             an unblocked reduction, as described in _Matrix_Computations_,
             by Golub and van Loan (Johns Hopkins Press).

   subroutine cggqrf (integer N, integer M, integer P, complex, dimension( lda, * ) A, integer
       LDA, complex, dimension( * ) TAUA, complex, dimension( ldb, * ) B, integer LDB, complex,
       dimension( * ) TAUB, complex, dimension( * ) WORK, integer LWORK, integer INFO)
       CGGQRF

       Purpose:

            CGGQRF computes a generalized QR factorization of an N-by-M matrix A
            and an N-by-P matrix B:

                        A = Q*R,        B = Q*T*Z,

            where Q is an N-by-N unitary matrix, Z is a P-by-P unitary matrix,
            and R and T assume one of the forms:

            if N >= M,  R = ( R11 ) M  ,   or if N < M,  R = ( R11  R12 ) N,
                            (  0  ) N-M                         N   M-N
                               M

            where R11 is upper triangular, and

            if N <= P,  T = ( 0  T12 ) N,   or if N > P,  T = ( T11 ) N-P,
                             P-N  N                           ( T21 ) P
                                                                 P

            where T12 or T21 is upper triangular.

            In particular, if B is square and nonsingular, the GQR factorization
            of A and B implicitly gives the QR factorization of inv(B)*A:

                         inv(B)*A = Z**H * (inv(T)*R)

            where inv(B) denotes the inverse of the matrix B, and Z' denotes the
            conjugate transpose of matrix Z.

       Parameters
           N

                     N is INTEGER
                     The number of rows of the matrices A and B. N >= 0.

           M

                     M is INTEGER
                     The number of columns of the matrix A.  M >= 0.

           P

                     P is INTEGER
                     The number of columns of the matrix B.  P >= 0.

           A

                     A is COMPLEX array, dimension (LDA,M)
                     On entry, the N-by-M matrix A.
                     On exit, the elements on and above the diagonal of the array
                     contain the min(N,M)-by-M upper trapezoidal matrix R (R is
                     upper triangular if N >= M); the elements below the diagonal,
                     with the array TAUA, represent the unitary matrix Q as a
                     product of min(N,M) elementary reflectors (see Further
                     Details).

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= max(1,N).

           TAUA

                     TAUA is COMPLEX array, dimension (min(N,M))
                     The scalar factors of the elementary reflectors which
                     represent the unitary matrix Q (see Further Details).

           B

                     B is COMPLEX array, dimension (LDB,P)
                     On entry, the N-by-P matrix B.
                     On exit, if N <= P, the upper triangle of the subarray
                     B(1:N,P-N+1:P) contains the N-by-N upper triangular matrix T;
                     if N > P, the elements on and above the (N-P)-th subdiagonal
                     contain the N-by-P upper trapezoidal matrix T; the remaining
                     elements, with the array TAUB, represent the unitary
                     matrix Z as a product of elementary reflectors (see Further
                     Details).

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B. LDB >= max(1,N).

           TAUB

                     TAUB is COMPLEX array, dimension (min(N,P))
                     The scalar factors of the elementary reflectors which
                     represent the unitary matrix Z (see Further Details).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK >= max(1,N,M,P).
                     For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3),
                     where NB1 is the optimal blocksize for the QR factorization
                     of an N-by-M matrix, NB2 is the optimal blocksize for the
                     RQ factorization of an N-by-P matrix, and NB3 is the optimal
                     blocksize for a call of CUNMQR.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                      = 0:  successful exit
                      < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The matrix Q is represented as a product of elementary reflectors

                Q = H(1) H(2) . . . H(k), where k = min(n,m).

             Each H(i) has the form

                H(i) = I - taua * v * v**H

             where taua is a complex scalar, and v is a complex vector with
             v(1:i-1) = 0 and v(i) = 1; v(i+1:n) is stored on exit in A(i+1:n,i),
             and taua in TAUA(i).
             To form Q explicitly, use LAPACK subroutine CUNGQR.
             To use Q to update another matrix, use LAPACK subroutine CUNMQR.

             The matrix Z is represented as a product of elementary reflectors

                Z = H(1) H(2) . . . H(k), where k = min(n,p).

             Each H(i) has the form

                H(i) = I - taub * v * v**H

             where taub is a complex scalar, and v is a complex vector with
             v(p-k+i+1:p) = 0 and v(p-k+i) = 1; v(1:p-k+i-1) is stored on exit in
             B(n-k+i,1:p-k+i-1), and taub in TAUB(i).
             To form Z explicitly, use LAPACK subroutine CUNGRQ.
             To use Z to update another matrix, use LAPACK subroutine CUNMRQ.

   subroutine cggrqf (integer M, integer P, integer N, complex, dimension( lda, * ) A, integer
       LDA, complex, dimension( * ) TAUA, complex, dimension( ldb, * ) B, integer LDB, complex,
       dimension( * ) TAUB, complex, dimension( * ) WORK, integer LWORK, integer INFO)
       CGGRQF

       Purpose:

            CGGRQF computes a generalized RQ factorization of an M-by-N matrix A
            and a P-by-N matrix B:

                        A = R*Q,        B = Z*T*Q,

            where Q is an N-by-N unitary matrix, Z is a P-by-P unitary
            matrix, and R and T assume one of the forms:

            if M <= N,  R = ( 0  R12 ) M,   or if M > N,  R = ( R11 ) M-N,
                             N-M  M                           ( R21 ) N
                                                                 N

            where R12 or R21 is upper triangular, and

            if P >= N,  T = ( T11 ) N  ,   or if P < N,  T = ( T11  T12 ) P,
                            (  0  ) P-N                         P   N-P
                               N

            where T11 is upper triangular.

            In particular, if B is square and nonsingular, the GRQ factorization
            of A and B implicitly gives the RQ factorization of A*inv(B):

                         A*inv(B) = (R*inv(T))*Z**H

            where inv(B) denotes the inverse of the matrix B, and Z**H denotes the
            conjugate transpose of the matrix Z.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix A.  M >= 0.

           P

                     P is INTEGER
                     The number of rows of the matrix B.  P >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrices A and B. N >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the M-by-N matrix A.
                     On exit, if M <= N, the upper triangle of the subarray
                     A(1:M,N-M+1:N) contains the M-by-M upper triangular matrix R;
                     if M > N, the elements on and above the (M-N)-th subdiagonal
                     contain the M-by-N upper trapezoidal matrix R; the remaining
                     elements, with the array TAUA, represent the unitary
                     matrix Q as a product of elementary reflectors (see Further
                     Details).

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= max(1,M).

           TAUA

                     TAUA is COMPLEX array, dimension (min(M,N))
                     The scalar factors of the elementary reflectors which
                     represent the unitary matrix Q (see Further Details).

           B

                     B is COMPLEX array, dimension (LDB,N)
                     On entry, the P-by-N matrix B.
                     On exit, the elements on and above the diagonal of the array
                     contain the min(P,N)-by-N upper trapezoidal matrix T (T is
                     upper triangular if P >= N); the elements below the diagonal,
                     with the array TAUB, represent the unitary matrix Z as a
                     product of elementary reflectors (see Further Details).

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B. LDB >= max(1,P).

           TAUB

                     TAUB is COMPLEX array, dimension (min(P,N))
                     The scalar factors of the elementary reflectors which
                     represent the unitary matrix Z (see Further Details).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK >= max(1,N,M,P).
                     For optimum performance LWORK >= max(N,M,P)*max(NB1,NB2,NB3),
                     where NB1 is the optimal blocksize for the RQ factorization
                     of an M-by-N matrix, NB2 is the optimal blocksize for the
                     QR factorization of a P-by-N matrix, and NB3 is the optimal
                     blocksize for a call of CUNMRQ.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO=-i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The matrix Q is represented as a product of elementary reflectors

                Q = H(1) H(2) . . . H(k), where k = min(m,n).

             Each H(i) has the form

                H(i) = I - taua * v * v**H

             where taua is a complex scalar, and v is a complex vector with
             v(n-k+i+1:n) = 0 and v(n-k+i) = 1; v(1:n-k+i-1) is stored on exit in
             A(m-k+i,1:n-k+i-1), and taua in TAUA(i).
             To form Q explicitly, use LAPACK subroutine CUNGRQ.
             To use Q to update another matrix, use LAPACK subroutine CUNMRQ.

             The matrix Z is represented as a product of elementary reflectors

                Z = H(1) H(2) . . . H(k), where k = min(p,n).

             Each H(i) has the form

                H(i) = I - taub * v * v**H

             where taub is a complex scalar, and v is a complex vector with
             v(1:i-1) = 0 and v(i) = 1; v(i+1:p) is stored on exit in B(i+1:p,i),
             and taub in TAUB(i).
             To form Z explicitly, use LAPACK subroutine CUNGQR.
             To use Z to update another matrix, use LAPACK subroutine CUNMQR.

   subroutine cggsvp3 (character JOBU, character JOBV, character JOBQ, integer M, integer P,
       integer N, complex, dimension( lda, * ) A, integer LDA, complex, dimension( ldb, * ) B,
       integer LDB, real TOLA, real TOLB, integer K, integer L, complex, dimension( ldu, * ) U,
       integer LDU, complex, dimension( ldv, * ) V, integer LDV, complex, dimension( ldq, * ) Q,
       integer LDQ, integer, dimension( * ) IWORK, real, dimension( * ) RWORK, complex,
       dimension( * ) TAU, complex, dimension( * ) WORK, integer LWORK, integer INFO)
       CGGSVP3

       Purpose:

            CGGSVP3 computes unitary matrices U, V and Q such that

                               N-K-L  K    L
             U**H*A*Q =     K ( 0    A12  A13 )  if M-K-L >= 0;
                            L ( 0     0   A23 )
                        M-K-L ( 0     0    0  )

                             N-K-L  K    L
                    =     K ( 0    A12  A13 )  if M-K-L < 0;
                        M-K ( 0     0   A23 )

                             N-K-L  K    L
             V**H*B*Q =   L ( 0     0   B13 )
                        P-L ( 0     0    0  )

            where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular
            upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,
            otherwise A23 is (M-K)-by-L upper trapezoidal.  K+L = the effective
            numerical rank of the (M+P)-by-N matrix (A**H,B**H)**H.

            This decomposition is the preprocessing step for computing the
            Generalized Singular Value Decomposition (GSVD), see subroutine
            CGGSVD3.

       Parameters
           JOBU

                     JOBU is CHARACTER*1
                     = 'U':  Unitary matrix U is computed;
                     = 'N':  U is not computed.

           JOBV

                     JOBV is CHARACTER*1
                     = 'V':  Unitary matrix V is computed;
                     = 'N':  V is not computed.

           JOBQ

                     JOBQ is CHARACTER*1
                     = 'Q':  Unitary matrix Q is computed;
                     = 'N':  Q is not computed.

           M

                     M is INTEGER
                     The number of rows of the matrix A.  M >= 0.

           P

                     P is INTEGER
                     The number of rows of the matrix B.  P >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrices A and B.  N >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the M-by-N matrix A.
                     On exit, A contains the triangular (or trapezoidal) matrix
                     described in the Purpose section.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= max(1,M).

           B

                     B is COMPLEX array, dimension (LDB,N)
                     On entry, the P-by-N matrix B.
                     On exit, B contains the triangular matrix described in
                     the Purpose section.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B. LDB >= max(1,P).

           TOLA

                     TOLA is REAL

           TOLB

                     TOLB is REAL

                     TOLA and TOLB are the thresholds to determine the effective
                     numerical rank of matrix B and a subblock of A. Generally,
                     they are set to
                        TOLA = MAX(M,N)*norm(A)*MACHEPS,
                        TOLB = MAX(P,N)*norm(B)*MACHEPS.
                     The size of TOLA and TOLB may affect the size of backward
                     errors of the decomposition.

           K

                     K is INTEGER

           L

                     L is INTEGER

                     On exit, K and L specify the dimension of the subblocks
                     described in Purpose section.
                     K + L = effective numerical rank of (A**H,B**H)**H.

           U

                     U is COMPLEX array, dimension (LDU,M)
                     If JOBU = 'U', U contains the unitary matrix U.
                     If JOBU = 'N', U is not referenced.

           LDU

                     LDU is INTEGER
                     The leading dimension of the array U. LDU >= max(1,M) if
                     JOBU = 'U'; LDU >= 1 otherwise.

           V

                     V is COMPLEX array, dimension (LDV,P)
                     If JOBV = 'V', V contains the unitary matrix V.
                     If JOBV = 'N', V is not referenced.

           LDV

                     LDV is INTEGER
                     The leading dimension of the array V. LDV >= max(1,P) if
                     JOBV = 'V'; LDV >= 1 otherwise.

           Q

                     Q is COMPLEX array, dimension (LDQ,N)
                     If JOBQ = 'Q', Q contains the unitary matrix Q.
                     If JOBQ = 'N', Q is not referenced.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q. LDQ >= max(1,N) if
                     JOBQ = 'Q'; LDQ >= 1 otherwise.

           IWORK

                     IWORK is INTEGER array, dimension (N)

           RWORK

                     RWORK is REAL array, dimension (2*N)

           TAU

                     TAU is COMPLEX array, dimension (N)

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The subroutine uses LAPACK subroutine CGEQP3 for the QR factorization
             with column pivoting to detect the effective numerical rank of the
             a matrix. It may be replaced by a better rank determination strategy.

             CGGSVP3 replaces the deprecated subroutine CGGSVP.

   subroutine cgsvj0 (character*1 JOBV, integer M, integer N, complex, dimension( lda, * ) A,
       integer LDA, complex, dimension( n ) D, real, dimension( n ) SVA, integer MV, complex,
       dimension( ldv, * ) V, integer LDV, real EPS, real SFMIN, real TOL, integer NSWEEP,
       complex, dimension( lwork ) WORK, integer LWORK, integer INFO)
       CGSVJ0 pre-processor for the routine cgesvj.

       Purpose:

            CGSVJ0 is called from CGESVJ as a pre-processor and that is its main
            purpose. It applies Jacobi rotations in the same way as CGESVJ does, but
            it does not check convergence (stopping criterion). Few tuning
            parameters (marked by [TP]) are available for the implementer.

       Parameters
           JOBV

                     JOBV is CHARACTER*1
                     Specifies whether the output from this procedure is used
                     to compute the matrix V:
                     = 'V': the product of the Jacobi rotations is accumulated
                            by postmulyiplying the N-by-N array V.
                           (See the description of V.)
                     = 'A': the product of the Jacobi rotations is accumulated
                            by postmulyiplying the MV-by-N array V.
                           (See the descriptions of MV and V.)
                     = 'N': the Jacobi rotations are not accumulated.

           M

                     M is INTEGER
                     The number of rows of the input matrix A.  M >= 0.

           N

                     N is INTEGER
                     The number of columns of the input matrix A.
                     M >= N >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, M-by-N matrix A, such that A*diag(D) represents
                     the input matrix.
                     On exit,
                     A_onexit * diag(D_onexit) represents the input matrix A*diag(D)
                     post-multiplied by a sequence of Jacobi rotations, where the
                     rotation threshold and the total number of sweeps are given in
                     TOL and NSWEEP, respectively.
                     (See the descriptions of D, TOL and NSWEEP.)

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,M).

           D

                     D is COMPLEX array, dimension (N)
                     The array D accumulates the scaling factors from the complex scaled
                     Jacobi rotations.
                     On entry, A*diag(D) represents the input matrix.
                     On exit, A_onexit*diag(D_onexit) represents the input matrix
                     post-multiplied by a sequence of Jacobi rotations, where the
                     rotation threshold and the total number of sweeps are given in
                     TOL and NSWEEP, respectively.
                     (See the descriptions of A, TOL and NSWEEP.)

           SVA

                     SVA is REAL array, dimension (N)
                     On entry, SVA contains the Euclidean norms of the columns of
                     the matrix A*diag(D).
                     On exit, SVA contains the Euclidean norms of the columns of
                     the matrix A_onexit*diag(D_onexit).

           MV

                     MV is INTEGER
                     If JOBV = 'A', then MV rows of V are post-multipled by a
                                      sequence of Jacobi rotations.
                     If JOBV = 'N',   then MV is not referenced.

           V

                     V is COMPLEX array, dimension (LDV,N)
                     If JOBV = 'V' then N rows of V are post-multipled by a
                                      sequence of Jacobi rotations.
                     If JOBV = 'A' then MV rows of V are post-multipled by a
                                      sequence of Jacobi rotations.
                     If JOBV = 'N',   then V is not referenced.

           LDV

                     LDV is INTEGER
                     The leading dimension of the array V,  LDV >= 1.
                     If JOBV = 'V', LDV >= N.
                     If JOBV = 'A', LDV >= MV.

           EPS

                     EPS is REAL
                     EPS = SLAMCH('Epsilon')

           SFMIN

                     SFMIN is REAL
                     SFMIN = SLAMCH('Safe Minimum')

           TOL

                     TOL is REAL
                     TOL is the threshold for Jacobi rotations. For a pair
                     A(:,p), A(:,q) of pivot columns, the Jacobi rotation is
                     applied only if ABS(COS(angle(A(:,p),A(:,q)))) > TOL.

           NSWEEP

                     NSWEEP is INTEGER
                     NSWEEP is the number of sweeps of Jacobi rotations to be
                     performed.

           WORK

                     WORK is COMPLEX array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     LWORK is the dimension of WORK. LWORK >= M.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, then the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:
           CGSVJ0 is used just to enable CGESVJ to call a simplified version of itself to work on
           a submatrix of the original matrix.

       Contributor:
           Zlatko Drmac (Zagreb, Croatia)

       Bugs, Examples and Comments:
           Please report all bugs and send interesting test examples and comments to
           drmac@math.hr. Thank you.

   subroutine cgsvj1 (character*1 JOBV, integer M, integer N, integer N1, complex, dimension(
       lda, * ) A, integer LDA, complex, dimension( n ) D, real, dimension( n ) SVA, integer MV,
       complex, dimension( ldv, * ) V, integer LDV, real EPS, real SFMIN, real TOL, integer
       NSWEEP, complex, dimension( lwork ) WORK, integer LWORK, integer INFO)
       CGSVJ1 pre-processor for the routine cgesvj, applies Jacobi rotations targeting only
       particular pivots.

       Purpose:

            CGSVJ1 is called from CGESVJ as a pre-processor and that is its main
            purpose. It applies Jacobi rotations in the same way as CGESVJ does, but
            it targets only particular pivots and it does not check convergence
            (stopping criterion). Few tuning parameters (marked by [TP]) are
            available for the implementer.

            Further Details
            ~~~~~~~~~~~~~~~
            CGSVJ1 applies few sweeps of Jacobi rotations in the column space of
            the input M-by-N matrix A. The pivot pairs are taken from the (1,2)
            off-diagonal block in the corresponding N-by-N Gram matrix A^T * A. The
            block-entries (tiles) of the (1,2) off-diagonal block are marked by the
            [x]'s in the following scheme:

               | *  *  * [x] [x] [x]|
               | *  *  * [x] [x] [x]|    Row-cycling in the nblr-by-nblc [x] blocks.
               | *  *  * [x] [x] [x]|    Row-cyclic pivoting inside each [x] block.
               |[x] [x] [x] *  *  * |
               |[x] [x] [x] *  *  * |
               |[x] [x] [x] *  *  * |

            In terms of the columns of A, the first N1 columns are rotated 'against'
            the remaining N-N1 columns, trying to increase the angle between the
            corresponding subspaces. The off-diagonal block is N1-by(N-N1) and it is
            tiled using quadratic tiles of side KBL. Here, KBL is a tuning parameter.
            The number of sweeps is given in NSWEEP and the orthogonality threshold
            is given in TOL.

       Parameters
           JOBV

                     JOBV is CHARACTER*1
                     Specifies whether the output from this procedure is used
                     to compute the matrix V:
                     = 'V': the product of the Jacobi rotations is accumulated
                            by postmulyiplying the N-by-N array V.
                           (See the description of V.)
                     = 'A': the product of the Jacobi rotations is accumulated
                            by postmulyiplying the MV-by-N array V.
                           (See the descriptions of MV and V.)
                     = 'N': the Jacobi rotations are not accumulated.

           M

                     M is INTEGER
                     The number of rows of the input matrix A.  M >= 0.

           N

                     N is INTEGER
                     The number of columns of the input matrix A.
                     M >= N >= 0.

           N1

                     N1 is INTEGER
                     N1 specifies the 2 x 2 block partition, the first N1 columns are
                     rotated 'against' the remaining N-N1 columns of A.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, M-by-N matrix A, such that A*diag(D) represents
                     the input matrix.
                     On exit,
                     A_onexit * D_onexit represents the input matrix A*diag(D)
                     post-multiplied by a sequence of Jacobi rotations, where the
                     rotation threshold and the total number of sweeps are given in
                     TOL and NSWEEP, respectively.
                     (See the descriptions of N1, D, TOL and NSWEEP.)

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,M).

           D

                     D is COMPLEX array, dimension (N)
                     The array D accumulates the scaling factors from the fast scaled
                     Jacobi rotations.
                     On entry, A*diag(D) represents the input matrix.
                     On exit, A_onexit*diag(D_onexit) represents the input matrix
                     post-multiplied by a sequence of Jacobi rotations, where the
                     rotation threshold and the total number of sweeps are given in
                     TOL and NSWEEP, respectively.
                     (See the descriptions of N1, A, TOL and NSWEEP.)

           SVA

                     SVA is REAL array, dimension (N)
                     On entry, SVA contains the Euclidean norms of the columns of
                     the matrix A*diag(D).
                     On exit, SVA contains the Euclidean norms of the columns of
                     the matrix onexit*diag(D_onexit).

           MV

                     MV is INTEGER
                     If JOBV = 'A', then MV rows of V are post-multipled by a
                                      sequence of Jacobi rotations.
                     If JOBV = 'N',   then MV is not referenced.

           V

                     V is COMPLEX array, dimension (LDV,N)
                     If JOBV = 'V' then N rows of V are post-multipled by a
                                      sequence of Jacobi rotations.
                     If JOBV = 'A' then MV rows of V are post-multipled by a
                                      sequence of Jacobi rotations.
                     If JOBV = 'N',   then V is not referenced.

           LDV

                     LDV is INTEGER
                     The leading dimension of the array V,  LDV >= 1.
                     If JOBV = 'V', LDV >= N.
                     If JOBV = 'A', LDV >= MV.

           EPS

                     EPS is REAL
                     EPS = SLAMCH('Epsilon')

           SFMIN

                     SFMIN is REAL
                     SFMIN = SLAMCH('Safe Minimum')

           TOL

                     TOL is REAL
                     TOL is the threshold for Jacobi rotations. For a pair
                     A(:,p), A(:,q) of pivot columns, the Jacobi rotation is
                     applied only if ABS(COS(angle(A(:,p),A(:,q)))) > TOL.

           NSWEEP

                     NSWEEP is INTEGER
                     NSWEEP is the number of sweeps of Jacobi rotations to be
                     performed.

           WORK

                    WORK is COMPLEX array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     LWORK is the dimension of WORK. LWORK >= M.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, then the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributor:
           Zlatko Drmac (Zagreb, Croatia)

   subroutine chbgst (character VECT, character UPLO, integer N, integer KA, integer KB, complex,
       dimension( ldab, * ) AB, integer LDAB, complex, dimension( ldbb, * ) BB, integer LDBB,
       complex, dimension( ldx, * ) X, integer LDX, complex, dimension( * ) WORK, real,
       dimension( * ) RWORK, integer INFO)
       CHBGST

       Purpose:

            CHBGST reduces a complex Hermitian-definite banded generalized
            eigenproblem  A*x = lambda*B*x  to standard form  C*y = lambda*y,
            such that C has the same bandwidth as A.

            B must have been previously factorized as S**H*S by CPBSTF, using a
            split Cholesky factorization. A is overwritten by C = X**H*A*X, where
            X = S**(-1)*Q and Q is a unitary matrix chosen to preserve the
            bandwidth of A.

       Parameters
           VECT

                     VECT is CHARACTER*1
                     = 'N':  do not form the transformation matrix X;
                     = 'V':  form X.

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrices A and B.  N >= 0.

           KA

                     KA is INTEGER
                     The number of superdiagonals of the matrix A if UPLO = 'U',
                     or the number of subdiagonals if UPLO = 'L'.  KA >= 0.

           KB

                     KB is INTEGER
                     The number of superdiagonals of the matrix B if UPLO = 'U',
                     or the number of subdiagonals if UPLO = 'L'.  KA >= KB >= 0.

           AB

                     AB is COMPLEX array, dimension (LDAB,N)
                     On entry, the upper or lower triangle of the Hermitian band
                     matrix A, stored in the first ka+1 rows of the array.  The
                     j-th column of A is stored in the j-th column of the array AB
                     as follows:
                     if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;
                     if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).

                     On exit, the transformed matrix X**H*A*X, stored in the same
                     format as A.

           LDAB

                     LDAB is INTEGER
                     The leading dimension of the array AB.  LDAB >= KA+1.

           BB

                     BB is COMPLEX array, dimension (LDBB,N)
                     The banded factor S from the split Cholesky factorization of
                     B, as returned by CPBSTF, stored in the first kb+1 rows of
                     the array.

           LDBB

                     LDBB is INTEGER
                     The leading dimension of the array BB.  LDBB >= KB+1.

           X

                     X is COMPLEX array, dimension (LDX,N)
                     If VECT = 'V', the n-by-n matrix X.
                     If VECT = 'N', the array X is not referenced.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.
                     LDX >= max(1,N) if VECT = 'V'; LDX >= 1 otherwise.

           WORK

                     WORK is COMPLEX array, dimension (N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine chbtrd (character VECT, character UPLO, integer N, integer KD, complex, dimension(
       ldab, * ) AB, integer LDAB, real, dimension( * ) D, real, dimension( * ) E, complex,
       dimension( ldq, * ) Q, integer LDQ, complex, dimension( * ) WORK, integer INFO)
       CHBTRD

       Purpose:

            CHBTRD reduces a complex Hermitian band matrix A to real symmetric
            tridiagonal form T by a unitary similarity transformation:
            Q**H * A * Q = T.

       Parameters
           VECT

                     VECT is CHARACTER*1
                     = 'N':  do not form Q;
                     = 'V':  form Q;
                     = 'U':  update a matrix X, by forming X*Q.

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           KD

                     KD is INTEGER
                     The number of superdiagonals of the matrix A if UPLO = 'U',
                     or the number of subdiagonals if UPLO = 'L'.  KD >= 0.

           AB

                     AB is COMPLEX array, dimension (LDAB,N)
                     On entry, the upper or lower triangle of the Hermitian band
                     matrix A, stored in the first KD+1 rows of the array.  The
                     j-th column of A is stored in the j-th column of the array AB
                     as follows:
                     if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
                     if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).
                     On exit, the diagonal elements of AB are overwritten by the
                     diagonal elements of the tridiagonal matrix T; if KD > 0, the
                     elements on the first superdiagonal (if UPLO = 'U') or the
                     first subdiagonal (if UPLO = 'L') are overwritten by the
                     off-diagonal elements of T; the rest of AB is overwritten by
                     values generated during the reduction.

           LDAB

                     LDAB is INTEGER
                     The leading dimension of the array AB.  LDAB >= KD+1.

           D

                     D is REAL array, dimension (N)
                     The diagonal elements of the tridiagonal matrix T.

           E

                     E is REAL array, dimension (N-1)
                     The off-diagonal elements of the tridiagonal matrix T:
                     E(i) = T(i,i+1) if UPLO = 'U'; E(i) = T(i+1,i) if UPLO = 'L'.

           Q

                     Q is COMPLEX array, dimension (LDQ,N)
                     On entry, if VECT = 'U', then Q must contain an N-by-N
                     matrix X; if VECT = 'N' or 'V', then Q need not be set.

                     On exit:
                     if VECT = 'V', Q contains the N-by-N unitary matrix Q;
                     if VECT = 'U', Q contains the product X*Q;
                     if VECT = 'N', the array Q is not referenced.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q.
                     LDQ >= 1, and LDQ >= N if VECT = 'V' or 'U'.

           WORK

                     WORK is COMPLEX array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             Modified by Linda Kaufman, Bell Labs.

   subroutine chetrd_hb2st (character STAGE1, character VECT, character UPLO, integer N, integer
       KD, complex, dimension( ldab, * ) AB, integer LDAB, real, dimension( * ) D, real,
       dimension( * ) E, complex, dimension( * ) HOUS, integer LHOUS, complex, dimension( * )
       WORK, integer LWORK, integer INFO)
       CHETRD_HB2ST reduces a complex Hermitian band matrix A to real symmetric tridiagonal form
       T

       Purpose:

            CHETRD_HB2ST reduces a complex Hermitian band matrix A to real symmetric
            tridiagonal form T by a unitary similarity transformation:
            Q**H * A * Q = T.

       Parameters
           STAGE1

                     STAGE1 is CHARACTER*1
                     = 'N':  "No": to mention that the stage 1 of the reduction
                             from dense to band using the chetrd_he2hb routine
                             was not called before this routine to reproduce AB.
                             In other term this routine is called as standalone.
                     = 'Y':  "Yes": to mention that the stage 1 of the
                             reduction from dense to band using the chetrd_he2hb
                             routine has been called to produce AB (e.g., AB is
                             the output of chetrd_he2hb.

           VECT

                     VECT is CHARACTER*1
                     = 'N':  No need for the Housholder representation,
                             and thus LHOUS is of size max(1, 4*N);
                     = 'V':  the Householder representation is needed to
                             either generate or to apply Q later on,
                             then LHOUS is to be queried and computed.
                             (NOT AVAILABLE IN THIS RELEASE).

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           KD

                     KD is INTEGER
                     The number of superdiagonals of the matrix A if UPLO = 'U',
                     or the number of subdiagonals if UPLO = 'L'.  KD >= 0.

           AB

                     AB is COMPLEX array, dimension (LDAB,N)
                     On entry, the upper or lower triangle of the Hermitian band
                     matrix A, stored in the first KD+1 rows of the array.  The
                     j-th column of A is stored in the j-th column of the array AB
                     as follows:
                     if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
                     if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).
                     On exit, the diagonal elements of AB are overwritten by the
                     diagonal elements of the tridiagonal matrix T; if KD > 0, the
                     elements on the first superdiagonal (if UPLO = 'U') or the
                     first subdiagonal (if UPLO = 'L') are overwritten by the
                     off-diagonal elements of T; the rest of AB is overwritten by
                     values generated during the reduction.

           LDAB

                     LDAB is INTEGER
                     The leading dimension of the array AB.  LDAB >= KD+1.

           D

                     D is REAL array, dimension (N)
                     The diagonal elements of the tridiagonal matrix T.

           E

                     E is REAL array, dimension (N-1)
                     The off-diagonal elements of the tridiagonal matrix T:
                     E(i) = T(i,i+1) if UPLO = 'U'; E(i) = T(i+1,i) if UPLO = 'L'.

           HOUS

                     HOUS is COMPLEX array, dimension LHOUS, that
                     store the Householder representation.

           LHOUS

                     LHOUS is INTEGER
                     The dimension of the array HOUS. LHOUS = MAX(1, dimension)
                     If LWORK = -1, or LHOUS=-1,
                     then a query is assumed; the routine
                     only calculates the optimal size of the HOUS array, returns
                     this value as the first entry of the HOUS array, and no error
                     message related to LHOUS is issued by XERBLA.
                     LHOUS = MAX(1, dimension) where
                     dimension = 4*N if VECT='N'
                     not available now if VECT='H'

           WORK

                     WORK is COMPLEX array, dimension LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK = MAX(1, dimension)
                     If LWORK = -1, or LHOUS=-1,
                     then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.
                     LWORK = MAX(1, dimension) where
                     dimension   = (2KD+1)*N + KD*NTHREADS
                     where KD is the blocking size of the reduction,
                     FACTOPTNB is the blocking used by the QR or LQ
                     algorithm, usually FACTOPTNB=128 is a good choice
                     NTHREADS is the number of threads used when
                     openMP compilation is enabled, otherwise =1.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             Implemented by Azzam Haidar.

             All details are available on technical report, SC11, SC13 papers.

             Azzam Haidar, Hatem Ltaief, and Jack Dongarra.
             Parallel reduction to condensed forms for symmetric eigenvalue problems
             using aggregated fine-grained and memory-aware kernels. In Proceedings
             of 2011 International Conference for High Performance Computing,
             Networking, Storage and Analysis (SC '11), New York, NY, USA,
             Article 8 , 11 pages.
             http://doi.acm.org/10.1145/2063384.2063394

             A. Haidar, J. Kurzak, P. Luszczek, 2013.
             An improved parallel singular value algorithm and its implementation
             for multicore hardware, In Proceedings of 2013 International Conference
             for High Performance Computing, Networking, Storage and Analysis (SC '13).
             Denver, Colorado, USA, 2013.
             Article 90, 12 pages.
             http://doi.acm.org/10.1145/2503210.2503292

             A. Haidar, R. Solca, S. Tomov, T. Schulthess and J. Dongarra.
             A novel hybrid CPU-GPU generalized eigensolver for electronic structure
             calculations based on fine-grained memory aware tasks.
             International Journal of High Performance Computing Applications.
             Volume 28 Issue 2, Pages 196-209, May 2014.
             http://hpc.sagepub.com/content/28/2/196

   subroutine chfrk (character TRANSR, character UPLO, character TRANS, integer N, integer K,
       real ALPHA, complex, dimension( lda, * ) A, integer LDA, real BETA, complex, dimension( *
       ) C)
       CHFRK performs a Hermitian rank-k operation for matrix in RFP format.

       Purpose:

            Level 3 BLAS like routine for C in RFP Format.

            CHFRK performs one of the Hermitian rank--k operations

               C := alpha*A*A**H + beta*C,

            or

               C := alpha*A**H*A + beta*C,

            where alpha and beta are real scalars, C is an n--by--n Hermitian
            matrix and A is an n--by--k matrix in the first case and a k--by--n
            matrix in the second case.

       Parameters
           TRANSR

                     TRANSR is CHARACTER*1
                     = 'N':  The Normal Form of RFP A is stored;
                     = 'C':  The Conjugate-transpose Form of RFP A is stored.

           UPLO

                     UPLO is CHARACTER*1
                      On  entry,   UPLO  specifies  whether  the  upper  or  lower
                      triangular  part  of the  array  C  is to be  referenced  as
                      follows:

                         UPLO = 'U' or 'u'   Only the  upper triangular part of  C
                                             is to be referenced.

                         UPLO = 'L' or 'l'   Only the  lower triangular part of  C
                                             is to be referenced.

                      Unchanged on exit.

           TRANS

                     TRANS is CHARACTER*1
                      On entry,  TRANS  specifies the operation to be performed as
                      follows:

                         TRANS = 'N' or 'n'   C := alpha*A*A**H + beta*C.

                         TRANS = 'C' or 'c'   C := alpha*A**H*A + beta*C.

                      Unchanged on exit.

           N

                     N is INTEGER
                      On entry,  N specifies the order of the matrix C.  N must be
                      at least zero.
                      Unchanged on exit.

           K

                     K is INTEGER
                      On entry with  TRANS = 'N' or 'n',  K  specifies  the number
                      of  columns   of  the   matrix   A,   and  on   entry   with
                      TRANS = 'C' or 'c',  K  specifies  the number of rows of the
                      matrix A.  K must be at least zero.
                      Unchanged on exit.

           ALPHA

                     ALPHA is REAL
                      On entry, ALPHA specifies the scalar alpha.
                      Unchanged on exit.

           A

                     A is COMPLEX array, dimension (LDA,ka)
                      where KA
                      is K  when TRANS = 'N' or 'n', and is N otherwise. Before
                      entry with TRANS = 'N' or 'n', the leading N--by--K part of
                      the array A must contain the matrix A, otherwise the leading
                      K--by--N part of the array A must contain the matrix A.
                      Unchanged on exit.

           LDA

                     LDA is INTEGER
                      On entry, LDA specifies the first dimension of A as declared
                      in  the  calling  (sub)  program.   When  TRANS = 'N' or 'n'
                      then  LDA must be at least  max( 1, n ), otherwise  LDA must
                      be at least  max( 1, k ).
                      Unchanged on exit.

           BETA

                     BETA is REAL
                      On entry, BETA specifies the scalar beta.
                      Unchanged on exit.

           C

                     C is COMPLEX array, dimension (N*(N+1)/2)
                      On entry, the matrix A in RFP Format. RFP Format is
                      described by TRANSR, UPLO and N. Note that the imaginary
                      parts of the diagonal elements need not be set, they are
                      assumed to be zero, and on exit they are set to zero.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine chpcon (character UPLO, integer N, complex, dimension( * ) AP, integer, dimension(
       * ) IPIV, real ANORM, real RCOND, complex, dimension( * ) WORK, integer INFO)
       CHPCON

       Purpose:

            CHPCON estimates the reciprocal of the condition number of a complex
            Hermitian packed matrix A using the factorization A = U*D*U**H or
            A = L*D*L**H computed by CHPTRF.

            An estimate is obtained for norm(inv(A)), and the reciprocal of the
            condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the details of the factorization are stored
                     as an upper or lower triangular matrix.
                     = 'U':  Upper triangular, form is A = U*D*U**H;
                     = 'L':  Lower triangular, form is A = L*D*L**H.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The block diagonal matrix D and the multipliers used to
                     obtain the factor U or L as computed by CHPTRF, stored as a
                     packed triangular matrix.

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by CHPTRF.

           ANORM

                     ANORM is REAL
                     The 1-norm of the original matrix A.

           RCOND

                     RCOND is REAL
                     The reciprocal of the condition number of the matrix A,
                     computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an
                     estimate of the 1-norm of inv(A) computed in this routine.

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine chpgst (integer ITYPE, character UPLO, integer N, complex, dimension( * ) AP,
       complex, dimension( * ) BP, integer INFO)
       CHPGST

       Purpose:

            CHPGST reduces a complex Hermitian-definite generalized
            eigenproblem to standard form, using packed storage.

            If ITYPE = 1, the problem is A*x = lambda*B*x,
            and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H)

            If ITYPE = 2 or 3, the problem is A*B*x = lambda*x or
            B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L.

            B must have been previously factorized as U**H*U or L*L**H by CPPTRF.

       Parameters
           ITYPE

                     ITYPE is INTEGER
                     = 1: compute inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H);
                     = 2 or 3: compute U*A*U**H or L**H*A*L.

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored and B is factored as
                             U**H*U;
                     = 'L':  Lower triangle of A is stored and B is factored as
                             L*L**H.

           N

                     N is INTEGER
                     The order of the matrices A and B.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     On entry, the upper or lower triangle of the Hermitian matrix
                     A, packed columnwise in a linear array.  The j-th column of A
                     is stored in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

                     On exit, if INFO = 0, the transformed matrix, stored in the
                     same format as A.

           BP

                     BP is COMPLEX array, dimension (N*(N+1)/2)
                     The triangular factor from the Cholesky factorization of B,
                     stored in the same format as A, as returned by CPPTRF.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine chprfs (character UPLO, integer N, integer NRHS, complex, dimension( * ) AP,
       complex, dimension( * ) AFP, integer, dimension( * ) IPIV, complex, dimension( ldb, * ) B,
       integer LDB, complex, dimension( ldx, * ) X, integer LDX, real, dimension( * ) FERR, real,
       dimension( * ) BERR, complex, dimension( * ) WORK, real, dimension( * ) RWORK, integer
       INFO)
       CHPRFS

       Purpose:

            CHPRFS improves the computed solution to a system of linear
            equations when the coefficient matrix is Hermitian indefinite
            and packed, and provides error bounds and backward error estimates
            for the solution.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrices B and X.  NRHS >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The upper or lower triangle of the Hermitian matrix A, packed
                     columnwise in a linear array.  The j-th column of A is stored
                     in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.

           AFP

                     AFP is COMPLEX array, dimension (N*(N+1)/2)
                     The factored form of the matrix A.  AFP contains the block
                     diagonal matrix D and the multipliers used to obtain the
                     factor U or L from the factorization A = U*D*U**H or
                     A = L*D*L**H as computed by CHPTRF, stored as a packed
                     triangular matrix.

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by CHPTRF.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     The right hand side matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           X

                     X is COMPLEX array, dimension (LDX,NRHS)
                     On entry, the solution matrix X, as computed by CHPTRS.
                     On exit, the improved solution matrix X.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  LDX >= max(1,N).

           FERR

                     FERR is REAL array, dimension (NRHS)
                     The estimated forward error bound for each solution vector
                     X(j) (the j-th column of the solution matrix X).
                     If XTRUE is the true solution corresponding to X(j), FERR(j)
                     is an estimated upper bound for the magnitude of the largest
                     element in (X(j) - XTRUE) divided by the magnitude of the
                     largest element in X(j).  The estimate is as reliable as
                     the estimate for RCOND, and is almost always a slight
                     overestimate of the true error.

           BERR

                     BERR is REAL array, dimension (NRHS)
                     The componentwise relative backward error of each solution
                     vector X(j) (i.e., the smallest relative change in
                     any element of A or B that makes X(j) an exact solution).

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Internal Parameters:

             ITMAX is the maximum number of steps of iterative refinement.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine chptrd (character UPLO, integer N, complex, dimension( * ) AP, real, dimension( * )
       D, real, dimension( * ) E, complex, dimension( * ) TAU, integer INFO)
       CHPTRD

       Purpose:

            CHPTRD reduces a complex Hermitian matrix A stored in packed form to
            real symmetric tridiagonal form T by a unitary similarity
            transformation: Q**H * A * Q = T.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     On entry, the upper or lower triangle of the Hermitian matrix
                     A, packed columnwise in a linear array.  The j-th column of A
                     is stored in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.
                     On exit, if UPLO = 'U', the diagonal and first superdiagonal
                     of A are overwritten by the corresponding elements of the
                     tridiagonal matrix T, and the elements above the first
                     superdiagonal, with the array TAU, represent the unitary
                     matrix Q as a product of elementary reflectors; if UPLO
                     = 'L', the diagonal and first subdiagonal of A are over-
                     written by the corresponding elements of the tridiagonal
                     matrix T, and the elements below the first subdiagonal, with
                     the array TAU, represent the unitary matrix Q as a product
                     of elementary reflectors. See Further Details.

           D

                     D is REAL array, dimension (N)
                     The diagonal elements of the tridiagonal matrix T:
                     D(i) = A(i,i).

           E

                     E is REAL array, dimension (N-1)
                     The off-diagonal elements of the tridiagonal matrix T:
                     E(i) = A(i,i+1) if UPLO = 'U', E(i) = A(i+1,i) if UPLO = 'L'.

           TAU

                     TAU is COMPLEX array, dimension (N-1)
                     The scalar factors of the elementary reflectors (see Further
                     Details).

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             If UPLO = 'U', the matrix Q is represented as a product of elementary
             reflectors

                Q = H(n-1) . . . H(2) H(1).

             Each H(i) has the form

                H(i) = I - tau * v * v**H

             where tau is a complex scalar, and v is a complex vector with
             v(i+1:n) = 0 and v(i) = 1; v(1:i-1) is stored on exit in AP,
             overwriting A(1:i-1,i+1), and tau is stored in TAU(i).

             If UPLO = 'L', the matrix Q is represented as a product of elementary
             reflectors

                Q = H(1) H(2) . . . H(n-1).

             Each H(i) has the form

                H(i) = I - tau * v * v**H

             where tau is a complex scalar, and v is a complex vector with
             v(1:i) = 0 and v(i+1) = 1; v(i+2:n) is stored on exit in AP,
             overwriting A(i+2:n,i), and tau is stored in TAU(i).

   subroutine chptrf (character UPLO, integer N, complex, dimension( * ) AP, integer, dimension(
       * ) IPIV, integer INFO)
       CHPTRF

       Purpose:

            CHPTRF computes the factorization of a complex Hermitian packed
            matrix A using the Bunch-Kaufman diagonal pivoting method:

               A = U*D*U**H  or  A = L*D*L**H

            where U (or L) is a product of permutation and unit upper (lower)
            triangular matrices, and D is Hermitian and block diagonal with
            1-by-1 and 2-by-2 diagonal blocks.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     On entry, the upper or lower triangle of the Hermitian matrix
                     A, packed columnwise in a linear array.  The j-th column of A
                     is stored in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

                     On exit, the block diagonal matrix D and the multipliers used
                     to obtain the factor U or L, stored as a packed triangular
                     matrix overwriting A (see below for further details).

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D.
                     If IPIV(k) > 0, then rows and columns k and IPIV(k) were
                     interchanged and D(k,k) is a 1-by-1 diagonal block.
                     If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and
                     columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)
                     is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =
                     IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were
                     interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block.

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value
                     > 0: if INFO = i, D(i,i) is exactly zero.  The factorization
                          has been completed, but the block diagonal matrix D is
                          exactly singular, and division by zero will occur if it
                          is used to solve a system of equations.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             If UPLO = 'U', then A = U*D*U**H, where
                U = P(n)*U(n)* ... *P(k)U(k)* ...,
             i.e., U is a product of terms P(k)*U(k), where k decreases from n to
             1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
             and 2-by-2 diagonal blocks D(k).  P(k) is a permutation matrix as
             defined by IPIV(k), and U(k) is a unit upper triangular matrix, such
             that if the diagonal block D(k) is of order s (s = 1 or 2), then

                        (   I    v    0   )   k-s
                U(k) =  (   0    I    0   )   s
                        (   0    0    I   )   n-k
                           k-s   s   n-k

             If s = 1, D(k) overwrites A(k,k), and v overwrites A(1:k-1,k).
             If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
             and A(k,k), and v overwrites A(1:k-2,k-1:k).

             If UPLO = 'L', then A = L*D*L**H, where
                L = P(1)*L(1)* ... *P(k)*L(k)* ...,
             i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
             n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
             and 2-by-2 diagonal blocks D(k).  P(k) is a permutation matrix as
             defined by IPIV(k), and L(k) is a unit lower triangular matrix, such
             that if the diagonal block D(k) is of order s (s = 1 or 2), then

                        (   I    0     0   )  k-1
                L(k) =  (   0    I     0   )  s
                        (   0    v     I   )  n-k-s+1
                           k-1   s  n-k-s+1

             If s = 1, D(k) overwrites A(k,k), and v overwrites A(k+1:n,k).
             If s = 2, the lower triangle of D(k) overwrites A(k,k), A(k+1,k),
             and A(k+1,k+1), and v overwrites A(k+2:n,k:k+1).

       Contributors:
           J. Lewis, Boeing Computer Services Company

   subroutine chptri (character UPLO, integer N, complex, dimension( * ) AP, integer, dimension(
       * ) IPIV, complex, dimension( * ) WORK, integer INFO)
       CHPTRI

       Purpose:

            CHPTRI computes the inverse of a complex Hermitian indefinite matrix
            A in packed storage using the factorization A = U*D*U**H or
            A = L*D*L**H computed by CHPTRF.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the details of the factorization are stored
                     as an upper or lower triangular matrix.
                     = 'U':  Upper triangular, form is A = U*D*U**H;
                     = 'L':  Lower triangular, form is A = L*D*L**H.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     On entry, the block diagonal matrix D and the multipliers
                     used to obtain the factor U or L as computed by CHPTRF,
                     stored as a packed triangular matrix.

                     On exit, if INFO = 0, the (Hermitian) inverse of the original
                     matrix, stored as a packed triangular matrix. The j-th column
                     of inv(A) is stored in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;
                     if UPLO = 'L',
                        AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n.

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by CHPTRF.

           WORK

                     WORK is COMPLEX array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value
                     > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its
                          inverse could not be computed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine chptrs (character UPLO, integer N, integer NRHS, complex, dimension( * ) AP,
       integer, dimension( * ) IPIV, complex, dimension( ldb, * ) B, integer LDB, integer INFO)
       CHPTRS

       Purpose:

            CHPTRS solves a system of linear equations A*X = B with a complex
            Hermitian matrix A stored in packed format using the factorization
            A = U*D*U**H or A = L*D*L**H computed by CHPTRF.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the details of the factorization are stored
                     as an upper or lower triangular matrix.
                     = 'U':  Upper triangular, form is A = U*D*U**H;
                     = 'L':  Lower triangular, form is A = L*D*L**H.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrix B.  NRHS >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The block diagonal matrix D and the multipliers used to
                     obtain the factor U or L as computed by CHPTRF, stored as a
                     packed triangular matrix.

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by CHPTRF.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     On entry, the right hand side matrix B.
                     On exit, the solution matrix X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine chsein (character SIDE, character EIGSRC, character INITV, logical, dimension( * )
       SELECT, integer N, complex, dimension( ldh, * ) H, integer LDH, complex, dimension( * ) W,
       complex, dimension( ldvl, * ) VL, integer LDVL, complex, dimension( ldvr, * ) VR, integer
       LDVR, integer MM, integer M, complex, dimension( * ) WORK, real, dimension( * ) RWORK,
       integer, dimension( * ) IFAILL, integer, dimension( * ) IFAILR, integer INFO)
       CHSEIN

       Purpose:

            CHSEIN uses inverse iteration to find specified right and/or left
            eigenvectors of a complex upper Hessenberg matrix H.

            The right eigenvector x and the left eigenvector y of the matrix H
            corresponding to an eigenvalue w are defined by:

                         H * x = w * x,     y**h * H = w * y**h

            where y**h denotes the conjugate transpose of the vector y.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'R': compute right eigenvectors only;
                     = 'L': compute left eigenvectors only;
                     = 'B': compute both right and left eigenvectors.

           EIGSRC

                     EIGSRC is CHARACTER*1
                     Specifies the source of eigenvalues supplied in W:
                     = 'Q': the eigenvalues were found using CHSEQR; thus, if
                            H has zero subdiagonal elements, and so is
                            block-triangular, then the j-th eigenvalue can be
                            assumed to be an eigenvalue of the block containing
                            the j-th row/column.  This property allows CHSEIN to
                            perform inverse iteration on just one diagonal block.
                     = 'N': no assumptions are made on the correspondence
                            between eigenvalues and diagonal blocks.  In this
                            case, CHSEIN must always perform inverse iteration
                            using the whole matrix H.

           INITV

                     INITV is CHARACTER*1
                     = 'N': no initial vectors are supplied;
                     = 'U': user-supplied initial vectors are stored in the arrays
                            VL and/or VR.

           SELECT

                     SELECT is LOGICAL array, dimension (N)
                     Specifies the eigenvectors to be computed. To select the
                     eigenvector corresponding to the eigenvalue W(j),
                     SELECT(j) must be set to .TRUE..

           N

                     N is INTEGER
                     The order of the matrix H.  N >= 0.

           H

                     H is COMPLEX array, dimension (LDH,N)
                     The upper Hessenberg matrix H.
                     If a NaN is detected in H, the routine will return with INFO=-6.

           LDH

                     LDH is INTEGER
                     The leading dimension of the array H.  LDH >= max(1,N).

           W

                     W is COMPLEX array, dimension (N)
                     On entry, the eigenvalues of H.
                     On exit, the real parts of W may have been altered since
                     close eigenvalues are perturbed slightly in searching for
                     independent eigenvectors.

           VL

                     VL is COMPLEX array, dimension (LDVL,MM)
                     On entry, if INITV = 'U' and SIDE = 'L' or 'B', VL must
                     contain starting vectors for the inverse iteration for the
                     left eigenvectors; the starting vector for each eigenvector
                     must be in the same column in which the eigenvector will be
                     stored.
                     On exit, if SIDE = 'L' or 'B', the left eigenvectors
                     specified by SELECT will be stored consecutively in the
                     columns of VL, in the same order as their eigenvalues.
                     If SIDE = 'R', VL is not referenced.

           LDVL

                     LDVL is INTEGER
                     The leading dimension of the array VL.
                     LDVL >= max(1,N) if SIDE = 'L' or 'B'; LDVL >= 1 otherwise.

           VR

                     VR is COMPLEX array, dimension (LDVR,MM)
                     On entry, if INITV = 'U' and SIDE = 'R' or 'B', VR must
                     contain starting vectors for the inverse iteration for the
                     right eigenvectors; the starting vector for each eigenvector
                     must be in the same column in which the eigenvector will be
                     stored.
                     On exit, if SIDE = 'R' or 'B', the right eigenvectors
                     specified by SELECT will be stored consecutively in the
                     columns of VR, in the same order as their eigenvalues.
                     If SIDE = 'L', VR is not referenced.

           LDVR

                     LDVR is INTEGER
                     The leading dimension of the array VR.
                     LDVR >= max(1,N) if SIDE = 'R' or 'B'; LDVR >= 1 otherwise.

           MM

                     MM is INTEGER
                     The number of columns in the arrays VL and/or VR. MM >= M.

           M

                     M is INTEGER
                     The number of columns in the arrays VL and/or VR required to
                     store the eigenvectors (= the number of .TRUE. elements in
                     SELECT).

           WORK

                     WORK is COMPLEX array, dimension (N*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           IFAILL

                     IFAILL is INTEGER array, dimension (MM)
                     If SIDE = 'L' or 'B', IFAILL(i) = j > 0 if the left
                     eigenvector in the i-th column of VL (corresponding to the
                     eigenvalue w(j)) failed to converge; IFAILL(i) = 0 if the
                     eigenvector converged satisfactorily.
                     If SIDE = 'R', IFAILL is not referenced.

           IFAILR

                     IFAILR is INTEGER array, dimension (MM)
                     If SIDE = 'R' or 'B', IFAILR(i) = j > 0 if the right
                     eigenvector in the i-th column of VR (corresponding to the
                     eigenvalue w(j)) failed to converge; IFAILR(i) = 0 if the
                     eigenvector converged satisfactorily.
                     If SIDE = 'L', IFAILR is not referenced.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value
                     > 0:  if INFO = i, i is the number of eigenvectors which
                           failed to converge; see IFAILL and IFAILR for further
                           details.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             Each eigenvector is normalized so that the element of largest
             magnitude has magnitude 1; here the magnitude of a complex number
             (x,y) is taken to be |x|+|y|.

   subroutine chseqr (character JOB, character COMPZ, integer N, integer ILO, integer IHI,
       complex, dimension( ldh, * ) H, integer LDH, complex, dimension( * ) W, complex,
       dimension( ldz, * ) Z, integer LDZ, complex, dimension( * ) WORK, integer LWORK, integer
       INFO)
       CHSEQR

       Purpose:

               CHSEQR computes the eigenvalues of a Hessenberg matrix H
               and, optionally, the matrices T and Z from the Schur decomposition
               H = Z T Z**H, where T is an upper triangular matrix (the
               Schur form), and Z is the unitary matrix of Schur vectors.

               Optionally Z may be postmultiplied into an input unitary
               matrix Q so that this routine can give the Schur factorization
               of a matrix A which has been reduced to the Hessenberg form H
               by the unitary matrix Q:  A = Q*H*Q**H = (QZ)*T*(QZ)**H.

       Parameters
           JOB

                     JOB is CHARACTER*1
                      = 'E':  compute eigenvalues only;
                      = 'S':  compute eigenvalues and the Schur form T.

           COMPZ

                     COMPZ is CHARACTER*1
                      = 'N':  no Schur vectors are computed;
                      = 'I':  Z is initialized to the unit matrix and the matrix Z
                              of Schur vectors of H is returned;
                      = 'V':  Z must contain an unitary matrix Q on entry, and
                              the product Q*Z is returned.

           N

                     N is INTEGER
                      The order of the matrix H.  N >= 0.

           ILO

                     ILO is INTEGER

           IHI

                     IHI is INTEGER

                      It is assumed that H is already upper triangular in rows
                      and columns 1:ILO-1 and IHI+1:N. ILO and IHI are normally
                      set by a previous call to CGEBAL, and then passed to ZGEHRD
                      when the matrix output by CGEBAL is reduced to Hessenberg
                      form. Otherwise ILO and IHI should be set to 1 and N
                      respectively.  If N > 0, then 1 <= ILO <= IHI <= N.
                      If N = 0, then ILO = 1 and IHI = 0.

           H

                     H is COMPLEX array, dimension (LDH,N)
                      On entry, the upper Hessenberg matrix H.
                      On exit, if INFO = 0 and JOB = 'S', H contains the upper
                      triangular matrix T from the Schur decomposition (the
                      Schur form). If INFO = 0 and JOB = 'E', the contents of
                      H are unspecified on exit.  (The output value of H when
                      INFO > 0 is given under the description of INFO below.)

                      Unlike earlier versions of CHSEQR, this subroutine may
                      explicitly H(i,j) = 0 for i > j and j = 1, 2, ... ILO-1
                      or j = IHI+1, IHI+2, ... N.

           LDH

                     LDH is INTEGER
                      The leading dimension of the array H. LDH >= max(1,N).

           W

                     W is COMPLEX array, dimension (N)
                      The computed eigenvalues. If JOB = 'S', the eigenvalues are
                      stored in the same order as on the diagonal of the Schur
                      form returned in H, with W(i) = H(i,i).

           Z

                     Z is COMPLEX array, dimension (LDZ,N)
                      If COMPZ = 'N', Z is not referenced.
                      If COMPZ = 'I', on entry Z need not be set and on exit,
                      if INFO = 0, Z contains the unitary matrix Z of the Schur
                      vectors of H.  If COMPZ = 'V', on entry Z must contain an
                      N-by-N matrix Q, which is assumed to be equal to the unit
                      matrix except for the submatrix Z(ILO:IHI,ILO:IHI). On exit,
                      if INFO = 0, Z contains Q*Z.
                      Normally Q is the unitary matrix generated by CUNGHR
                      after the call to CGEHRD which formed the Hessenberg matrix
                      H. (The output value of Z when INFO > 0 is given under
                      the description of INFO below.)

           LDZ

                     LDZ is INTEGER
                      The leading dimension of the array Z.  if COMPZ = 'I' or
                      COMPZ = 'V', then LDZ >= MAX(1,N).  Otherwise, LDZ >= 1.

           WORK

                     WORK is COMPLEX array, dimension (LWORK)
                      On exit, if INFO = 0, WORK(1) returns an estimate of
                      the optimal value for LWORK.

           LWORK

                     LWORK is INTEGER
                      The dimension of the array WORK.  LWORK >= max(1,N)
                      is sufficient and delivers very good and sometimes
                      optimal performance.  However, LWORK as large as 11*N
                      may be required for optimal performance.  A workspace
                      query is recommended to determine the optimal workspace
                      size.

                      If LWORK = -1, then CHSEQR does a workspace query.
                      In this case, CHSEQR checks the input parameters and
                      estimates the optimal workspace size for the given
                      values of N, ILO and IHI.  The estimate is returned
                      in WORK(1).  No error message related to LWORK is
                      issued by XERBLA.  Neither H nor Z are accessed.

           INFO

                     INFO is INTEGER
                        = 0:  successful exit
                        < 0:  if INFO = -i, the i-th argument had an illegal
                               value
                        > 0:  if INFO = i, CHSEQR failed to compute all of
                           the eigenvalues.  Elements 1:ilo-1 and i+1:n of W
                           contain those eigenvalues which have been
                           successfully computed.  (Failures are rare.)

                           If INFO > 0 and JOB = 'E', then on exit, the
                           remaining unconverged eigenvalues are the eigen-
                           values of the upper Hessenberg matrix rows and
                           columns ILO through INFO of the final, output
                           value of H.

                           If INFO > 0 and JOB   = 'S', then on exit

                      (*)  (initial value of H)*U  = U*(final value of H)

                           where U is a unitary matrix.  The final
                           value of  H is upper Hessenberg and triangular in
                           rows and columns INFO+1 through IHI.

                           If INFO > 0 and COMPZ = 'V', then on exit

                             (final value of Z)  =  (initial value of Z)*U

                           where U is the unitary matrix in (*) (regard-
                           less of the value of JOB.)

                           If INFO > 0 and COMPZ = 'I', then on exit
                                 (final value of Z)  = U
                           where U is the unitary matrix in (*) (regard-
                           less of the value of JOB.)

                           If INFO > 0 and COMPZ = 'N', then Z is not
                           accessed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           Karen Braman and Ralph Byers, Department of Mathematics, University of Kansas, USA

       Further Details:

                        Default values supplied by
                        ILAENV(ISPEC,'CHSEQR',JOB(:1)//COMPZ(:1),N,ILO,IHI,LWORK).
                        It is suggested that these defaults be adjusted in order
                        to attain best performance in each particular
                        computational environment.

                       ISPEC=12: The CLAHQR vs CLAQR0 crossover point.
                                 Default: 75. (Must be at least 11.)

                       ISPEC=13: Recommended deflation window size.
                                 This depends on ILO, IHI and NS.  NS is the
                                 number of simultaneous shifts returned
                                 by ILAENV(ISPEC=15).  (See ISPEC=15 below.)
                                 The default for (IHI-ILO+1) <= 500 is NS.
                                 The default for (IHI-ILO+1) >  500 is 3*NS/2.

                       ISPEC=14: Nibble crossover point. (See IPARMQ for
                                 details.)  Default: 14% of deflation window
                                 size.

                       ISPEC=15: Number of simultaneous shifts in a multishift
                                 QR iteration.

                                 If IHI-ILO+1 is ...

                                 greater than      ...but less    ... the
                                 or equal to ...      than        default is

                                      1               30          NS =   2(+)
                                     30               60          NS =   4(+)
                                     60              150          NS =  10(+)
                                    150              590          NS =  **
                                    590             3000          NS =  64
                                   3000             6000          NS = 128
                                   6000             infinity      NS = 256

                             (+)  By default some or all matrices of this order
                                  are passed to the implicit double shift routine
                                  CLAHQR and this parameter is ignored.  See
                                  ISPEC=12 above and comments in IPARMQ for
                                  details.

                            (**)  The asterisks (**) indicate an ad-hoc
                                  function of N increasing from 10 to 64.

                       ISPEC=16: Select structured matrix multiply.
                                 If the number of simultaneous shifts (specified
                                 by ISPEC=15) is less than 14, then the default
                                 for ISPEC=16 is 0.  Otherwise the default for
                                 ISPEC=16 is 2.

       References:

             K. Braman, R. Byers and R. Mathias, The Multi-Shift QR
             Algorithm Part I: Maintaining Well Focused Shifts, and Level 3
             Performance, SIAM Journal of Matrix Analysis, volume 23, pages
             929--947, 2002.

            K. Braman, R. Byers and R. Mathias, The Multi-Shift QR Algorithm Part II: Aggressive
           Early Deflation, SIAM Journal of Matrix Analysis, volume 23, pages 948--973, 2002.

   subroutine cla_lin_berr (integer N, integer NZ, integer NRHS, complex, dimension( n, nrhs )
       RES, real, dimension( n, nrhs ) AYB, real, dimension( nrhs ) BERR)
       CLA_LIN_BERR computes a component-wise relative backward error.

       Purpose:

               CLA_LIN_BERR computes componentwise relative backward error from
               the formula
                   max(i) ( abs(R(i)) / ( abs(op(A_s))*abs(Y) + abs(B_s) )(i) )
               where abs(Z) is the componentwise absolute value of the matrix
               or vector Z.

       Parameters
           N

                     N is INTEGER
                The number of linear equations, i.e., the order of the
                matrix A.  N >= 0.

           NZ

                     NZ is INTEGER
                We add (NZ+1)*SLAMCH( 'Safe minimum' ) to R(i) in the numerator to
                guard against spuriously zero residuals. Default value is N.

           NRHS

                     NRHS is INTEGER
                The number of right hand sides, i.e., the number of columns
                of the matrices AYB, RES, and BERR.  NRHS >= 0.

           RES

                     RES is COMPLEX array, dimension (N,NRHS)
                The residual matrix, i.e., the matrix R in the relative backward
                error formula above.

           AYB

                     AYB is REAL array, dimension (N, NRHS)
                The denominator in the relative backward error formula above, i.e.,
                the matrix abs(op(A_s))*abs(Y) + abs(B_s). The matrices A, Y, and B
                are from iterative refinement (see cla_gerfsx_extended.f).

           BERR

                     BERR is REAL array, dimension (NRHS)
                The componentwise relative backward error from the formula above.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cla_wwaddw (integer N, complex, dimension( * ) X, complex, dimension( * ) Y,
       complex, dimension( * ) W)
       CLA_WWADDW adds a vector into a doubled-single vector.

       Purpose:

               CLA_WWADDW adds a vector W into a doubled-single vector (X, Y).

               This works for all extant IBM's hex and binary floating point
               arithmetic, but not for decimal.

       Parameters
           N

                     N is INTEGER
                       The length of vectors X, Y, and W.

           X

                     X is COMPLEX array, dimension (N)
                       The first part of the doubled-single accumulation vector.

           Y

                     Y is COMPLEX array, dimension (N)
                       The second part of the doubled-single accumulation vector.

           W

                     W is COMPLEX array, dimension (N)
                       The vector to be added.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine claed0 (integer QSIZ, integer N, real, dimension( * ) D, real, dimension( * ) E,
       complex, dimension( ldq, * ) Q, integer LDQ, complex, dimension( ldqs, * ) QSTORE, integer
       LDQS, real, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer INFO)
       CLAED0 used by CSTEDC. Computes all eigenvalues and corresponding eigenvectors of an
       unreduced symmetric tridiagonal matrix using the divide and conquer method.

       Purpose:

            Using the divide and conquer method, CLAED0 computes all eigenvalues
            of a symmetric tridiagonal matrix which is one diagonal block of
            those from reducing a dense or band Hermitian matrix and
            corresponding eigenvectors of the dense or band matrix.

       Parameters
           QSIZ

                     QSIZ is INTEGER
                    The dimension of the unitary matrix used to reduce
                    the full matrix to tridiagonal form.  QSIZ >= N if ICOMPQ = 1.

           N

                     N is INTEGER
                    The dimension of the symmetric tridiagonal matrix.  N >= 0.

           D

                     D is REAL array, dimension (N)
                    On entry, the diagonal elements of the tridiagonal matrix.
                    On exit, the eigenvalues in ascending order.

           E

                     E is REAL array, dimension (N-1)
                    On entry, the off-diagonal elements of the tridiagonal matrix.
                    On exit, E has been destroyed.

           Q

                     Q is COMPLEX array, dimension (LDQ,N)
                    On entry, Q must contain an QSIZ x N matrix whose columns
                    unitarily orthonormal. It is a part of the unitary matrix
                    that reduces the full dense Hermitian matrix to a
                    (reducible) symmetric tridiagonal matrix.

           LDQ

                     LDQ is INTEGER
                    The leading dimension of the array Q.  LDQ >= max(1,N).

           IWORK

                     IWORK is INTEGER array,
                    the dimension of IWORK must be at least
                                 6 + 6*N + 5*N*lg N
                                 ( lg( N ) = smallest integer k
                                             such that 2^k >= N )

           RWORK

                     RWORK is REAL array,
                                          dimension (1 + 3*N + 2*N*lg N + 3*N**2)
                                   ( lg( N ) = smallest integer k
                                               such that 2^k >= N )

           QSTORE

                     QSTORE is COMPLEX array, dimension (LDQS, N)
                    Used to store parts of
                    the eigenvector matrix when the updating matrix multiplies
                    take place.

           LDQS

                     LDQS is INTEGER
                    The leading dimension of the array QSTORE.
                    LDQS >= max(1,N).

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  The algorithm failed to compute an eigenvalue while
                           working on the submatrix lying in rows and columns
                           INFO/(N+1) through mod(INFO,N+1).

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine claed7 (integer N, integer CUTPNT, integer QSIZ, integer TLVLS, integer CURLVL,
       integer CURPBM, real, dimension( * ) D, complex, dimension( ldq, * ) Q, integer LDQ, real
       RHO, integer, dimension( * ) INDXQ, real, dimension( * ) QSTORE, integer, dimension( * )
       QPTR, integer, dimension( * ) PRMPTR, integer, dimension( * ) PERM, integer, dimension( *
       ) GIVPTR, integer, dimension( 2, * ) GIVCOL, real, dimension( 2, * ) GIVNUM, complex,
       dimension( * ) WORK, real, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer
       INFO)
       CLAED7 used by CSTEDC. Computes the updated eigensystem of a diagonal matrix after
       modification by a rank-one symmetric matrix. Used when the original matrix is dense.

       Purpose:

            CLAED7 computes the updated eigensystem of a diagonal
            matrix after modification by a rank-one symmetric matrix. This
            routine is used only for the eigenproblem which requires all
            eigenvalues and optionally eigenvectors of a dense or banded
            Hermitian matrix that has been reduced to tridiagonal form.

              T = Q(in) ( D(in) + RHO * Z*Z**H ) Q**H(in) = Q(out) * D(out) * Q**H(out)

              where Z = Q**Hu, u is a vector of length N with ones in the
              CUTPNT and CUTPNT + 1 th elements and zeros elsewhere.

               The eigenvectors of the original matrix are stored in Q, and the
               eigenvalues are in D.  The algorithm consists of three stages:

                  The first stage consists of deflating the size of the problem
                  when there are multiple eigenvalues or if there is a zero in
                  the Z vector.  For each such occurrence the dimension of the
                  secular equation problem is reduced by one.  This stage is
                  performed by the routine SLAED2.

                  The second stage consists of calculating the updated
                  eigenvalues. This is done by finding the roots of the secular
                  equation via the routine SLAED4 (as called by SLAED3).
                  This routine also calculates the eigenvectors of the current
                  problem.

                  The final stage consists of computing the updated eigenvectors
                  directly using the updated eigenvalues.  The eigenvectors for
                  the current problem are multiplied with the eigenvectors from
                  the overall problem.

       Parameters
           N

                     N is INTEGER
                    The dimension of the symmetric tridiagonal matrix.  N >= 0.

           CUTPNT

                     CUTPNT is INTEGER
                    Contains the location of the last eigenvalue in the leading
                    sub-matrix.  min(1,N) <= CUTPNT <= N.

           QSIZ

                     QSIZ is INTEGER
                    The dimension of the unitary matrix used to reduce
                    the full matrix to tridiagonal form.  QSIZ >= N.

           TLVLS

                     TLVLS is INTEGER
                    The total number of merging levels in the overall divide and
                    conquer tree.

           CURLVL

                     CURLVL is INTEGER
                    The current level in the overall merge routine,
                    0 <= curlvl <= tlvls.

           CURPBM

                     CURPBM is INTEGER
                    The current problem in the current level in the overall
                    merge routine (counting from upper left to lower right).

           D

                     D is REAL array, dimension (N)
                    On entry, the eigenvalues of the rank-1-perturbed matrix.
                    On exit, the eigenvalues of the repaired matrix.

           Q

                     Q is COMPLEX array, dimension (LDQ,N)
                    On entry, the eigenvectors of the rank-1-perturbed matrix.
                    On exit, the eigenvectors of the repaired tridiagonal matrix.

           LDQ

                     LDQ is INTEGER
                    The leading dimension of the array Q.  LDQ >= max(1,N).

           RHO

                     RHO is REAL
                    Contains the subdiagonal element used to create the rank-1
                    modification.

           INDXQ

                     INDXQ is INTEGER array, dimension (N)
                    This contains the permutation which will reintegrate the
                    subproblem just solved back into sorted order,
                    ie. D( INDXQ( I = 1, N ) ) will be in ascending order.

           IWORK

                     IWORK is INTEGER array, dimension (4*N)

           RWORK

                     RWORK is REAL array,
                                            dimension (3*N+2*QSIZ*N)

           WORK

                     WORK is COMPLEX array, dimension (QSIZ*N)

           QSTORE

                     QSTORE is REAL array, dimension (N**2+1)
                    Stores eigenvectors of submatrices encountered during
                    divide and conquer, packed together. QPTR points to
                    beginning of the submatrices.

           QPTR

                     QPTR is INTEGER array, dimension (N+2)
                    List of indices pointing to beginning of submatrices stored
                    in QSTORE. The submatrices are numbered starting at the
                    bottom left of the divide and conquer tree, from left to
                    right and bottom to top.

           PRMPTR

                     PRMPTR is INTEGER array, dimension (N lg N)
                    Contains a list of pointers which indicate where in PERM a
                    level's permutation is stored.  PRMPTR(i+1) - PRMPTR(i)
                    indicates the size of the permutation and also the size of
                    the full, non-deflated problem.

           PERM

                     PERM is INTEGER array, dimension (N lg N)
                    Contains the permutations (from deflation and sorting) to be
                    applied to each eigenblock.

           GIVPTR

                     GIVPTR is INTEGER array, dimension (N lg N)
                    Contains a list of pointers which indicate where in GIVCOL a
                    level's Givens rotations are stored.  GIVPTR(i+1) - GIVPTR(i)
                    indicates the number of Givens rotations.

           GIVCOL

                     GIVCOL is INTEGER array, dimension (2, N lg N)
                    Each pair of numbers indicates a pair of columns to take place
                    in a Givens rotation.

           GIVNUM

                     GIVNUM is REAL array, dimension (2, N lg N)
                    Each number indicates the S value to be used in the
                    corresponding Givens rotation.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  if INFO = 1, an eigenvalue did not converge

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine claed8 (integer K, integer N, integer QSIZ, complex, dimension( ldq, * ) Q, integer
       LDQ, real, dimension( * ) D, real RHO, integer CUTPNT, real, dimension( * ) Z, real,
       dimension( * ) DLAMDA, complex, dimension( ldq2, * ) Q2, integer LDQ2, real, dimension( *
       ) W, integer, dimension( * ) INDXP, integer, dimension( * ) INDX, integer, dimension( * )
       INDXQ, integer, dimension( * ) PERM, integer GIVPTR, integer, dimension( 2, * ) GIVCOL,
       real, dimension( 2, * ) GIVNUM, integer INFO)
       CLAED8 used by CSTEDC. Merges eigenvalues and deflates secular equation. Used when the
       original matrix is dense.

       Purpose:

            CLAED8 merges the two sets of eigenvalues together into a single
            sorted set.  Then it tries to deflate the size of the problem.
            There are two ways in which deflation can occur:  when two or more
            eigenvalues are close together or if there is a tiny element in the
            Z vector.  For each such occurrence the order of the related secular
            equation problem is reduced by one.

       Parameters
           K

                     K is INTEGER
                    Contains the number of non-deflated eigenvalues.
                    This is the order of the related secular equation.

           N

                     N is INTEGER
                    The dimension of the symmetric tridiagonal matrix.  N >= 0.

           QSIZ

                     QSIZ is INTEGER
                    The dimension of the unitary matrix used to reduce
                    the dense or band matrix to tridiagonal form.
                    QSIZ >= N if ICOMPQ = 1.

           Q

                     Q is COMPLEX array, dimension (LDQ,N)
                    On entry, Q contains the eigenvectors of the partially solved
                    system which has been previously updated in matrix
                    multiplies with other partially solved eigensystems.
                    On exit, Q contains the trailing (N-K) updated eigenvectors
                    (those which were deflated) in its last N-K columns.

           LDQ

                     LDQ is INTEGER
                    The leading dimension of the array Q.  LDQ >= max( 1, N ).

           D

                     D is REAL array, dimension (N)
                    On entry, D contains the eigenvalues of the two submatrices to
                    be combined.  On exit, D contains the trailing (N-K) updated
                    eigenvalues (those which were deflated) sorted into increasing
                    order.

           RHO

                     RHO is REAL
                    Contains the off diagonal element associated with the rank-1
                    cut which originally split the two submatrices which are now
                    being recombined. RHO is modified during the computation to
                    the value required by SLAED3.

           CUTPNT

                     CUTPNT is INTEGER
                    Contains the location of the last eigenvalue in the leading
                    sub-matrix.  MIN(1,N) <= CUTPNT <= N.

           Z

                     Z is REAL array, dimension (N)
                    On input this vector contains the updating vector (the last
                    row of the first sub-eigenvector matrix and the first row of
                    the second sub-eigenvector matrix).  The contents of Z are
                    destroyed during the updating process.

           DLAMDA

                     DLAMDA is REAL array, dimension (N)
                    Contains a copy of the first K eigenvalues which will be used
                    by SLAED3 to form the secular equation.

           Q2

                     Q2 is COMPLEX array, dimension (LDQ2,N)
                    If ICOMPQ = 0, Q2 is not referenced.  Otherwise,
                    Contains a copy of the first K eigenvectors which will be used
                    by SLAED7 in a matrix multiply (SGEMM) to update the new
                    eigenvectors.

           LDQ2

                     LDQ2 is INTEGER
                    The leading dimension of the array Q2.  LDQ2 >= max( 1, N ).

           W

                     W is REAL array, dimension (N)
                    This will hold the first k values of the final
                    deflation-altered z-vector and will be passed to SLAED3.

           INDXP

                     INDXP is INTEGER array, dimension (N)
                    This will contain the permutation used to place deflated
                    values of D at the end of the array. On output INDXP(1:K)
                    points to the nondeflated D-values and INDXP(K+1:N)
                    points to the deflated eigenvalues.

           INDX

                     INDX is INTEGER array, dimension (N)
                    This will contain the permutation used to sort the contents of
                    D into ascending order.

           INDXQ

                     INDXQ is INTEGER array, dimension (N)
                    This contains the permutation which separately sorts the two
                    sub-problems in D into ascending order.  Note that elements in
                    the second half of this permutation must first have CUTPNT
                    added to their values in order to be accurate.

           PERM

                     PERM is INTEGER array, dimension (N)
                    Contains the permutations (from deflation and sorting) to be
                    applied to each eigenblock.

           GIVPTR

                     GIVPTR is INTEGER
                    Contains the number of Givens rotations which took place in
                    this subproblem.

           GIVCOL

                     GIVCOL is INTEGER array, dimension (2, N)
                    Each pair of numbers indicates a pair of columns to take place
                    in a Givens rotation.

           GIVNUM

                     GIVNUM is REAL array, dimension (2, N)
                    Each number indicates the S value to be used in the
                    corresponding Givens rotation.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine clals0 (integer ICOMPQ, integer NL, integer NR, integer SQRE, integer NRHS,
       complex, dimension( ldb, * ) B, integer LDB, complex, dimension( ldbx, * ) BX, integer
       LDBX, integer, dimension( * ) PERM, integer GIVPTR, integer, dimension( ldgcol, * )
       GIVCOL, integer LDGCOL, real, dimension( ldgnum, * ) GIVNUM, integer LDGNUM, real,
       dimension( ldgnum, * ) POLES, real, dimension( * ) DIFL, real, dimension( ldgnum, * )
       DIFR, real, dimension( * ) Z, integer K, real C, real S, real, dimension( * ) RWORK,
       integer INFO)
       CLALS0 applies back multiplying factors in solving the least squares problem using divide
       and conquer SVD approach. Used by sgelsd.

       Purpose:

            CLALS0 applies back the multiplying factors of either the left or the
            right singular vector matrix of a diagonal matrix appended by a row
            to the right hand side matrix B in solving the least squares problem
            using the divide-and-conquer SVD approach.

            For the left singular vector matrix, three types of orthogonal
            matrices are involved:

            (1L) Givens rotations: the number of such rotations is GIVPTR; the
                 pairs of columns/rows they were applied to are stored in GIVCOL;
                 and the C- and S-values of these rotations are stored in GIVNUM.

            (2L) Permutation. The (NL+1)-st row of B is to be moved to the first
                 row, and for J=2:N, PERM(J)-th row of B is to be moved to the
                 J-th row.

            (3L) The left singular vector matrix of the remaining matrix.

            For the right singular vector matrix, four types of orthogonal
            matrices are involved:

            (1R) The right singular vector matrix of the remaining matrix.

            (2R) If SQRE = 1, one extra Givens rotation to generate the right
                 null space.

            (3R) The inverse transformation of (2L).

            (4R) The inverse transformation of (1L).

       Parameters
           ICOMPQ

                     ICOMPQ is INTEGER
                    Specifies whether singular vectors are to be computed in
                    factored form:
                    = 0: Left singular vector matrix.
                    = 1: Right singular vector matrix.

           NL

                     NL is INTEGER
                    The row dimension of the upper block. NL >= 1.

           NR

                     NR is INTEGER
                    The row dimension of the lower block. NR >= 1.

           SQRE

                     SQRE is INTEGER
                    = 0: the lower block is an NR-by-NR square matrix.
                    = 1: the lower block is an NR-by-(NR+1) rectangular matrix.

                    The bidiagonal matrix has row dimension N = NL + NR + 1,
                    and column dimension M = N + SQRE.

           NRHS

                     NRHS is INTEGER
                    The number of columns of B and BX. NRHS must be at least 1.

           B

                     B is COMPLEX array, dimension ( LDB, NRHS )
                    On input, B contains the right hand sides of the least
                    squares problem in rows 1 through M. On output, B contains
                    the solution X in rows 1 through N.

           LDB

                     LDB is INTEGER
                    The leading dimension of B. LDB must be at least
                    max(1,MAX( M, N ) ).

           BX

                     BX is COMPLEX array, dimension ( LDBX, NRHS )

           LDBX

                     LDBX is INTEGER
                    The leading dimension of BX.

           PERM

                     PERM is INTEGER array, dimension ( N )
                    The permutations (from deflation and sorting) applied
                    to the two blocks.

           GIVPTR

                     GIVPTR is INTEGER
                    The number of Givens rotations which took place in this
                    subproblem.

           GIVCOL

                     GIVCOL is INTEGER array, dimension ( LDGCOL, 2 )
                    Each pair of numbers indicates a pair of rows/columns
                    involved in a Givens rotation.

           LDGCOL

                     LDGCOL is INTEGER
                    The leading dimension of GIVCOL, must be at least N.

           GIVNUM

                     GIVNUM is REAL array, dimension ( LDGNUM, 2 )
                    Each number indicates the C or S value used in the
                    corresponding Givens rotation.

           LDGNUM

                     LDGNUM is INTEGER
                    The leading dimension of arrays DIFR, POLES and
                    GIVNUM, must be at least K.

           POLES

                     POLES is REAL array, dimension ( LDGNUM, 2 )
                    On entry, POLES(1:K, 1) contains the new singular
                    values obtained from solving the secular equation, and
                    POLES(1:K, 2) is an array containing the poles in the secular
                    equation.

           DIFL

                     DIFL is REAL array, dimension ( K ).
                    On entry, DIFL(I) is the distance between I-th updated
                    (undeflated) singular value and the I-th (undeflated) old
                    singular value.

           DIFR

                     DIFR is REAL array, dimension ( LDGNUM, 2 ).
                    On entry, DIFR(I, 1) contains the distances between I-th
                    updated (undeflated) singular value and the I+1-th
                    (undeflated) old singular value. And DIFR(I, 2) is the
                    normalizing factor for the I-th right singular vector.

           Z

                     Z is REAL array, dimension ( K )
                    Contain the components of the deflation-adjusted updating row
                    vector.

           K

                     K is INTEGER
                    Contains the dimension of the non-deflated matrix,
                    This is the order of the related secular equation. 1 <= K <=N.

           C

                     C is REAL
                    C contains garbage if SQRE =0 and the C-value of a Givens
                    rotation related to the right null space if SQRE = 1.

           S

                     S is REAL
                    S contains garbage if SQRE =0 and the S-value of a Givens
                    rotation related to the right null space if SQRE = 1.

           RWORK

                     RWORK is REAL array, dimension
                    ( K*(1+NRHS) + 2*NRHS )

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           Ming Gu and Ren-Cang Li, Computer Science Division, University of California at
           Berkeley, USA
            Osni Marques, LBNL/NERSC, USA

   subroutine clalsa (integer ICOMPQ, integer SMLSIZ, integer N, integer NRHS, complex,
       dimension( ldb, * ) B, integer LDB, complex, dimension( ldbx, * ) BX, integer LDBX, real,
       dimension( ldu, * ) U, integer LDU, real, dimension( ldu, * ) VT, integer, dimension( * )
       K, real, dimension( ldu, * ) DIFL, real, dimension( ldu, * ) DIFR, real, dimension( ldu, *
       ) Z, real, dimension( ldu, * ) POLES, integer, dimension( * ) GIVPTR, integer, dimension(
       ldgcol, * ) GIVCOL, integer LDGCOL, integer, dimension( ldgcol, * ) PERM, real, dimension(
       ldu, * ) GIVNUM, real, dimension( * ) C, real, dimension( * ) S, real, dimension( * )
       RWORK, integer, dimension( * ) IWORK, integer INFO)
       CLALSA computes the SVD of the coefficient matrix in compact form. Used by sgelsd.

       Purpose:

            CLALSA is an itermediate step in solving the least squares problem
            by computing the SVD of the coefficient matrix in compact form (The
            singular vectors are computed as products of simple orthorgonal
            matrices.).

            If ICOMPQ = 0, CLALSA applies the inverse of the left singular vector
            matrix of an upper bidiagonal matrix to the right hand side; and if
            ICOMPQ = 1, CLALSA applies the right singular vector matrix to the
            right hand side. The singular vector matrices were generated in
            compact form by CLALSA.

       Parameters
           ICOMPQ

                     ICOMPQ is INTEGER
                    Specifies whether the left or the right singular vector
                    matrix is involved.
                    = 0: Left singular vector matrix
                    = 1: Right singular vector matrix

           SMLSIZ

                     SMLSIZ is INTEGER
                    The maximum size of the subproblems at the bottom of the
                    computation tree.

           N

                     N is INTEGER
                    The row and column dimensions of the upper bidiagonal matrix.

           NRHS

                     NRHS is INTEGER
                    The number of columns of B and BX. NRHS must be at least 1.

           B

                     B is COMPLEX array, dimension ( LDB, NRHS )
                    On input, B contains the right hand sides of the least
                    squares problem in rows 1 through M.
                    On output, B contains the solution X in rows 1 through N.

           LDB

                     LDB is INTEGER
                    The leading dimension of B in the calling subprogram.
                    LDB must be at least max(1,MAX( M, N ) ).

           BX

                     BX is COMPLEX array, dimension ( LDBX, NRHS )
                    On exit, the result of applying the left or right singular
                    vector matrix to B.

           LDBX

                     LDBX is INTEGER
                    The leading dimension of BX.

           U

                     U is REAL array, dimension ( LDU, SMLSIZ ).
                    On entry, U contains the left singular vector matrices of all
                    subproblems at the bottom level.

           LDU

                     LDU is INTEGER, LDU = > N.
                    The leading dimension of arrays U, VT, DIFL, DIFR,
                    POLES, GIVNUM, and Z.

           VT

                     VT is REAL array, dimension ( LDU, SMLSIZ+1 ).
                    On entry, VT**H contains the right singular vector matrices of
                    all subproblems at the bottom level.

           K

                     K is INTEGER array, dimension ( N ).

           DIFL

                     DIFL is REAL array, dimension ( LDU, NLVL ).
                    where NLVL = INT(log_2 (N/(SMLSIZ+1))) + 1.

           DIFR

                     DIFR is REAL array, dimension ( LDU, 2 * NLVL ).
                    On entry, DIFL(*, I) and DIFR(*, 2 * I -1) record
                    distances between singular values on the I-th level and
                    singular values on the (I -1)-th level, and DIFR(*, 2 * I)
                    record the normalizing factors of the right singular vectors
                    matrices of subproblems on I-th level.

           Z

                     Z is REAL array, dimension ( LDU, NLVL ).
                    On entry, Z(1, I) contains the components of the deflation-
                    adjusted updating row vector for subproblems on the I-th
                    level.

           POLES

                     POLES is REAL array, dimension ( LDU, 2 * NLVL ).
                    On entry, POLES(*, 2 * I -1: 2 * I) contains the new and old
                    singular values involved in the secular equations on the I-th
                    level.

           GIVPTR

                     GIVPTR is INTEGER array, dimension ( N ).
                    On entry, GIVPTR( I ) records the number of Givens
                    rotations performed on the I-th problem on the computation
                    tree.

           GIVCOL

                     GIVCOL is INTEGER array, dimension ( LDGCOL, 2 * NLVL ).
                    On entry, for each I, GIVCOL(*, 2 * I - 1: 2 * I) records the
                    locations of Givens rotations performed on the I-th level on
                    the computation tree.

           LDGCOL

                     LDGCOL is INTEGER, LDGCOL = > N.
                    The leading dimension of arrays GIVCOL and PERM.

           PERM

                     PERM is INTEGER array, dimension ( LDGCOL, NLVL ).
                    On entry, PERM(*, I) records permutations done on the I-th
                    level of the computation tree.

           GIVNUM

                     GIVNUM is REAL array, dimension ( LDU, 2 * NLVL ).
                    On entry, GIVNUM(*, 2 *I -1 : 2 * I) records the C- and S-
                    values of Givens rotations performed on the I-th level on the
                    computation tree.

           C

                     C is REAL array, dimension ( N ).
                    On entry, if the I-th subproblem is not square,
                    C( I ) contains the C-value of a Givens rotation related to
                    the right null space of the I-th subproblem.

           S

                     S is REAL array, dimension ( N ).
                    On entry, if the I-th subproblem is not square,
                    S( I ) contains the S-value of a Givens rotation related to
                    the right null space of the I-th subproblem.

           RWORK

                     RWORK is REAL array, dimension at least
                    MAX( (SMLSZ+1)*NRHS*3, N*(1+NRHS) + 2*NRHS ).

           IWORK

                     IWORK is INTEGER array, dimension (3*N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           Ming Gu and Ren-Cang Li, Computer Science Division, University of California at
           Berkeley, USA
            Osni Marques, LBNL/NERSC, USA

   subroutine clalsd (character UPLO, integer SMLSIZ, integer N, integer NRHS, real, dimension( *
       ) D, real, dimension( * ) E, complex, dimension( ldb, * ) B, integer LDB, real RCOND,
       integer RANK, complex, dimension( * ) WORK, real, dimension( * ) RWORK, integer,
       dimension( * ) IWORK, integer INFO)
       CLALSD uses the singular value decomposition of A to solve the least squares problem.

       Purpose:

            CLALSD uses the singular value decomposition of A to solve the least
            squares problem of finding X to minimize the Euclidean norm of each
            column of A*X-B, where A is N-by-N upper bidiagonal, and X and B
            are N-by-NRHS. The solution X overwrites B.

            The singular values of A smaller than RCOND times the largest
            singular value are treated as zero in solving the least squares
            problem; in this case a minimum norm solution is returned.
            The actual singular values are returned in D in ascending order.

            This code makes very mild assumptions about floating point
            arithmetic. It will work on machines with a guard digit in
            add/subtract, or on those binary machines without guard digits
            which subtract like the Cray XMP, Cray YMP, Cray C 90, or Cray 2.
            It could conceivably fail on hexadecimal or decimal machines
            without guard digits, but we know of none.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                    = 'U': D and E define an upper bidiagonal matrix.
                    = 'L': D and E define a  lower bidiagonal matrix.

           SMLSIZ

                     SMLSIZ is INTEGER
                    The maximum size of the subproblems at the bottom of the
                    computation tree.

           N

                     N is INTEGER
                    The dimension of the  bidiagonal matrix.  N >= 0.

           NRHS

                     NRHS is INTEGER
                    The number of columns of B. NRHS must be at least 1.

           D

                     D is REAL array, dimension (N)
                    On entry D contains the main diagonal of the bidiagonal
                    matrix. On exit, if INFO = 0, D contains its singular values.

           E

                     E is REAL array, dimension (N-1)
                    Contains the super-diagonal entries of the bidiagonal matrix.
                    On exit, E has been destroyed.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                    On input, B contains the right hand sides of the least
                    squares problem. On output, B contains the solution X.

           LDB

                     LDB is INTEGER
                    The leading dimension of B in the calling subprogram.
                    LDB must be at least max(1,N).

           RCOND

                     RCOND is REAL
                    The singular values of A less than or equal to RCOND times
                    the largest singular value are treated as zero in solving
                    the least squares problem. If RCOND is negative,
                    machine precision is used instead.
                    For example, if diag(S)*X=B were the least squares problem,
                    where diag(S) is a diagonal matrix of singular values, the
                    solution would be X(i) = B(i) / S(i) if S(i) is greater than
                    RCOND*max(S), and X(i) = 0 if S(i) is less than or equal to
                    RCOND*max(S).

           RANK

                     RANK is INTEGER
                    The number of singular values of A greater than RCOND times
                    the largest singular value.

           WORK

                     WORK is COMPLEX array, dimension (N * NRHS).

           RWORK

                     RWORK is REAL array, dimension at least
                    (9*N + 2*N*SMLSIZ + 8*N*NLVL + 3*SMLSIZ*NRHS +
                    MAX( (SMLSIZ+1)**2, N*(1+NRHS) + 2*NRHS ),
                    where
                    NLVL = MAX( 0, INT( LOG_2( MIN( M,N )/(SMLSIZ+1) ) ) + 1 )

           IWORK

                     IWORK is INTEGER array, dimension (3*N*NLVL + 11*N).

           INFO

                     INFO is INTEGER
                    = 0:  successful exit.
                    < 0:  if INFO = -i, the i-th argument had an illegal value.
                    > 0:  The algorithm failed to compute a singular value while
                          working on the submatrix lying in rows and columns
                          INFO/(N+1) through MOD(INFO,N+1).

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           Ming Gu and Ren-Cang Li, Computer Science Division, University of California at
           Berkeley, USA
            Osni Marques, LBNL/NERSC, USA

   real function clanhf (character NORM, character TRANSR, character UPLO, integer N, complex,
       dimension( 0: * ) A, real, dimension( 0: * ) WORK)
       CLANHF returns the value of the 1-norm, or the Frobenius norm, or the infinity norm, or
       the element of largest absolute value of a Hermitian matrix in RFP format.

       Purpose:

            CLANHF  returns the value of the one norm,  or the Frobenius norm, or
            the  infinity norm,  or the  element of  largest absolute value  of a
            complex Hermitian matrix A in RFP format.

       Returns
           CLANHF

               CLANHF = ( max(abs(A(i,j))), NORM = 'M' or 'm'
                        (
                        ( norm1(A),         NORM = '1', 'O' or 'o'
                        (
                        ( normI(A),         NORM = 'I' or 'i'
                        (
                        ( normF(A),         NORM = 'F', 'f', 'E' or 'e'

            where  norm1  denotes the  one norm of a matrix (maximum column sum),
            normI  denotes the  infinity norm  of a matrix  (maximum row sum) and
            normF  denotes the  Frobenius norm of a matrix (square root of sum of
            squares).  Note that  max(abs(A(i,j)))  is not a  matrix norm.

       Parameters
           NORM

                     NORM is CHARACTER
                       Specifies the value to be returned in CLANHF as described
                       above.

           TRANSR

                     TRANSR is CHARACTER
                       Specifies whether the RFP format of A is normal or
                       conjugate-transposed format.
                       = 'N':  RFP format is Normal
                       = 'C':  RFP format is Conjugate-transposed

           UPLO

                     UPLO is CHARACTER
                       On entry, UPLO specifies whether the RFP matrix A came from
                       an upper or lower triangular matrix as follows:

                       UPLO = 'U' or 'u' RFP A came from an upper triangular
                       matrix

                       UPLO = 'L' or 'l' RFP A came from a  lower triangular
                       matrix

           N

                     N is INTEGER
                       The order of the matrix A.  N >= 0.  When N = 0, CLANHF is
                       set to zero.

           A

                     A is COMPLEX array, dimension ( N*(N+1)/2 );
                       On entry, the matrix A in RFP Format.
                       RFP Format is described by TRANSR, UPLO and N as follows:
                       If TRANSR='N' then RFP A is (0:N,0:K-1) when N is even;
                       K=N/2. RFP A is (0:N-1,0:K) when N is odd; K=N/2. If
                       TRANSR = 'C' then RFP is the Conjugate-transpose of RFP A
                       as defined when TRANSR = 'N'. The contents of RFP A are
                       defined by UPLO as follows: If UPLO = 'U' the RFP A
                       contains the ( N*(N+1)/2 ) elements of upper packed A
                       either in normal or conjugate-transpose Format. If
                       UPLO = 'L' the RFP A contains the ( N*(N+1) /2 ) elements
                       of lower packed A either in normal or conjugate-transpose
                       Format. The LDA of RFP A is (N+1)/2 when TRANSR = 'C'. When
                       TRANSR is 'N' the LDA is N+1 when N is even and is N when
                       is odd. See the Note below for more details.
                       Unchanged on exit.

           WORK

                     WORK is REAL array, dimension (LWORK),
                       where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,
                       WORK is not referenced.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             We first consider Standard Packed Format when N is even.
             We give an example where N = 6.

                 AP is Upper             AP is Lower

              00 01 02 03 04 05       00
                 11 12 13 14 15       10 11
                    22 23 24 25       20 21 22
                       33 34 35       30 31 32 33
                          44 45       40 41 42 43 44
                             55       50 51 52 53 54 55

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last
             three columns of AP upper. The lower triangle A(4:6,0:2) consists of
             conjugate-transpose of the first three columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:2,0:2) consists of
             conjugate-transpose of the last three columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N even and TRANSR = 'N'.

                    RFP A                   RFP A

                                           -- -- --
                   03 04 05                33 43 53
                                              -- --
                   13 14 15                00 44 54
                                                 --
                   23 24 25                10 11 55

                   33 34 35                20 21 22
                   --
                   00 44 45                30 31 32
                   -- --
                   01 11 55                40 41 42
                   -- -- --
                   02 12 22                50 51 52

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- -- --                -- -- -- -- -- --
                03 13 23 33 00 01 02    33 00 10 20 30 40 50
                -- -- -- -- --                -- -- -- -- --
                04 14 24 34 44 11 12    43 44 11 21 31 41 51
                -- -- -- -- -- --                -- -- -- --
                05 15 25 35 45 55 22    53 54 55 22 32 42 52

             We next  consider Standard Packed Format when N is odd.
             We give an example where N = 5.

                AP is Upper                 AP is Lower

              00 01 02 03 04              00
                 11 12 13 14              10 11
                    22 23 24              20 21 22
                       33 34              30 31 32 33
                          44              40 41 42 43 44

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last
             three columns of AP upper. The lower triangle A(3:4,0:1) consists of
             conjugate-transpose of the first two   columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:1,1:2) consists of
             conjugate-transpose of the last two   columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N odd  and TRANSR = 'N'.

                    RFP A                   RFP A

                                              -- --
                   02 03 04                00 33 43
                                                 --
                   12 13 14                10 11 44

                   22 23 24                20 21 22
                   --
                   00 33 34                30 31 32
                   -- --
                   01 11 44                40 41 42

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- --                   -- -- -- -- -- --
                02 12 22 00 01             00 10 20 30 40 50
                -- -- -- --                   -- -- -- -- --
                03 13 23 33 11             33 11 21 31 41 51
                -- -- -- -- --                   -- -- -- --
                04 14 24 34 44             43 44 22 32 42 52

   subroutine clarscl2 (integer M, integer N, real, dimension( * ) D, complex, dimension( ldx, *
       ) X, integer LDX)
       CLARSCL2 performs reciprocal diagonal scaling on a vector.

       Purpose:

            CLARSCL2 performs a reciprocal diagonal scaling on an vector:
              x <-- inv(D) * x
            where the REAL diagonal matrix D is stored as a vector.

            Eventually to be replaced by BLAS_cge_diag_scale in the new BLAS
            standard.

       Parameters
           M

                     M is INTEGER
                The number of rows of D and X. M >= 0.

           N

                     N is INTEGER
                The number of columns of X. N >= 0.

           D

                     D is REAL array, length M
                Diagonal matrix D, stored as a vector of length M.

           X

                     X is COMPLEX array, dimension (LDX,N)
                On entry, the vector X to be scaled by D.
                On exit, the scaled vector.

           LDX

                     LDX is INTEGER
                The leading dimension of the vector X. LDX >= M.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine clarz (character SIDE, integer M, integer N, integer L, complex, dimension( * ) V,
       integer INCV, complex TAU, complex, dimension( ldc, * ) C, integer LDC, complex,
       dimension( * ) WORK)
       CLARZ applies an elementary reflector (as returned by stzrzf) to a general matrix.

       Purpose:

            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.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': form  H * C
                     = 'R': form  C * H

           M

                     M is INTEGER
                     The number of rows of the matrix C.

           N

                     N is INTEGER
                     The number of columns of the matrix C.

           L

                     L is INTEGER
                     The number of entries of the vector V containing
                     the meaningful part of the Householder vectors.
                     If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0.

           V

                     V is COMPLEX array, dimension (1+(L-1)*abs(INCV))
                     The vector v in the representation of H as returned by
                     CTZRZF. V is not used if TAU = 0.

           INCV

                     INCV is INTEGER
                     The increment between elements of v. INCV <> 0.

           TAU

                     TAU is COMPLEX
                     The value tau in the representation of H.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by the matrix H * C if SIDE = 'L',
                     or C * H if SIDE = 'R'.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension
                                    (N) if SIDE = 'L'
                                 or (M) if SIDE = 'R'

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA

       Further Details:

   subroutine clarzb (character SIDE, character TRANS, character DIRECT, character STOREV,
       integer M, integer N, integer K, integer L, complex, dimension( ldv, * ) V, integer LDV,
       complex, dimension( ldt, * ) T, integer LDT, complex, dimension( ldc, * ) C, integer LDC,
       complex, dimension( ldwork, * ) WORK, integer LDWORK)
       CLARZB applies a block reflector or its conjugate-transpose to a general matrix.

       Purpose:

            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.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply H or H**H from the Left
                     = 'R': apply H or H**H from the Right

           TRANS

                     TRANS is CHARACTER*1
                     = 'N': apply H (No transpose)
                     = 'C': apply H**H (Conjugate transpose)

           DIRECT

                     DIRECT is CHARACTER*1
                     Indicates how H is formed from a product of elementary
                     reflectors
                     = 'F': H = H(1) H(2) . . . H(k) (Forward, not supported yet)
                     = 'B': H = H(k) . . . H(2) H(1) (Backward)

           STOREV

                     STOREV is CHARACTER*1
                     Indicates how the vectors which define the elementary
                     reflectors are stored:
                     = 'C': Columnwise                        (not supported yet)
                     = 'R': Rowwise

           M

                     M is INTEGER
                     The number of rows of the matrix C.

           N

                     N is INTEGER
                     The number of columns of the matrix C.

           K

                     K is INTEGER
                     The order of the matrix T (= the number of elementary
                     reflectors whose product defines the block reflector).

           L

                     L is INTEGER
                     The number of columns of the matrix V containing the
                     meaningful part of the Householder reflectors.
                     If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0.

           V

                     V is COMPLEX array, dimension (LDV,NV).
                     If STOREV = 'C', NV = K; if STOREV = 'R', NV = L.

           LDV

                     LDV is INTEGER
                     The leading dimension of the array V.
                     If STOREV = 'C', LDV >= L; if STOREV = 'R', LDV >= K.

           T

                     T is COMPLEX array, dimension (LDT,K)
                     The triangular K-by-K matrix T in the representation of the
                     block reflector.

           LDT

                     LDT is INTEGER
                     The leading dimension of the array T. LDT >= K.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by H*C or H**H*C or C*H or C*H**H.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension (LDWORK,K)

           LDWORK

                     LDWORK is INTEGER
                     The leading dimension of the array WORK.
                     If SIDE = 'L', LDWORK >= max(1,N);
                     if SIDE = 'R', LDWORK >= max(1,M).

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA

       Further Details:

   subroutine clarzt (character DIRECT, character STOREV, integer N, integer K, complex,
       dimension( ldv, * ) V, integer LDV, complex, dimension( * ) TAU, complex, dimension( ldt,
       * ) T, integer LDT)
       CLARZT forms the triangular factor T of a block reflector H = I - vtvH.

       Purpose:

            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.

       Parameters
           DIRECT

                     DIRECT is CHARACTER*1
                     Specifies the order in which the elementary reflectors are
                     multiplied to form the block reflector:
                     = 'F': H = H(1) H(2) . . . H(k) (Forward, not supported yet)
                     = 'B': H = H(k) . . . H(2) H(1) (Backward)

           STOREV

                     STOREV is CHARACTER*1
                     Specifies how the vectors which define the elementary
                     reflectors are stored (see also Further Details):
                     = 'C': columnwise                        (not supported yet)
                     = 'R': rowwise

           N

                     N is INTEGER
                     The order of the block reflector H. N >= 0.

           K

                     K is INTEGER
                     The order of the triangular factor T (= the number of
                     elementary reflectors). K >= 1.

           V

                     V is COMPLEX array, dimension
                                          (LDV,K) if STOREV = 'C'
                                          (LDV,N) if STOREV = 'R'
                     The matrix V. See further details.

           LDV

                     LDV is INTEGER
                     The leading dimension of the array V.
                     If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K.

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i).

           T

                     T is COMPLEX array, dimension (LDT,K)
                     The k by k triangular factor T of the block reflector.
                     If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is
                     lower triangular. The rest of the array is not used.

           LDT

                     LDT is INTEGER
                     The leading dimension of the array T. LDT >= K.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA

       Further Details:

             The shape of the matrix V and the storage of the vectors which define
             the H(i) is best illustrated by the following example with n = 5 and
             k = 3. The elements equal to 1 are not stored; the corresponding
             array elements are modified but restored on exit. The rest of the
             array is not used.

             DIRECT = 'F' and STOREV = 'C':         DIRECT = 'F' and STOREV = 'R':

                                                         ______V_____
                    ( v1 v2 v3 )                        /                     ( v1 v2 v3 )                      ( v1 v1 v1 v1 v1 . . . . 1 )
                V = ( v1 v2 v3 )                      ( v2 v2 v2 v2 v2 . . . 1   )
                    ( v1 v2 v3 )                      ( v3 v3 v3 v3 v3 . . 1     )
                    ( v1 v2 v3 )
                       .  .  .
                       .  .  .
                       1  .  .
                          1  .
                             1

             DIRECT = 'B' and STOREV = 'C':         DIRECT = 'B' and STOREV = 'R':

                                                                   ______V_____
                       1                                          /                        .  1                           ( 1 . . . . v1 v1 v1 v1 v1 )
                       .  .  1                        ( . 1 . . . v2 v2 v2 v2 v2 )
                       .  .  .                        ( . . 1 . . v3 v3 v3 v3 v3 )
                       .  .  .
                    ( v1 v2 v3 )
                    ( v1 v2 v3 )
                V = ( v1 v2 v3 )
                    ( v1 v2 v3 )
                    ( v1 v2 v3 )

   subroutine clascl2 (integer M, integer N, real, dimension( * ) D, complex, dimension( ldx, * )
       X, integer LDX)
       CLASCL2 performs diagonal scaling on a vector.

       Purpose:

            CLASCL2 performs a diagonal scaling on a vector:
              x <-- D * x
            where the diagonal REAL matrix D is stored as a vector.

            Eventually to be replaced by BLAS_cge_diag_scale in the new BLAS
            standard.

       Parameters
           M

                     M is INTEGER
                The number of rows of D and X. M >= 0.

           N

                     N is INTEGER
                The number of columns of X. N >= 0.

           D

                     D is REAL array, length M
                Diagonal matrix D, stored as a vector of length M.

           X

                     X is COMPLEX array, dimension (LDX,N)
                On entry, the vector X to be scaled by D.
                On exit, the scaled vector.

           LDX

                     LDX is INTEGER
                The leading dimension of the vector X. LDX >= M.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine clatrz (integer M, integer N, integer L, complex, dimension( lda, * ) A, integer
       LDA, complex, dimension( * ) TAU, complex, dimension( * ) WORK)
       CLATRZ factors an upper trapezoidal matrix by means of unitary transformations.

       Purpose:

            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.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix A.  M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix A.  N >= 0.

           L

                     L is INTEGER
                     The number of columns of the matrix A containing the
                     meaningful part of the Householder vectors. N-M >= L >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the leading M-by-N upper trapezoidal part of the
                     array A must contain the matrix to be factorized.
                     On exit, the leading M-by-M upper triangular part of A
                     contains the upper triangular matrix R, and elements N-L+1 to
                     N of the first M rows of A, with the array TAU, represent the
                     unitary matrix Z as a product of M elementary reflectors.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,M).

           TAU

                     TAU is COMPLEX array, dimension (M)
                     The scalar factors of the elementary reflectors.

           WORK

                     WORK is COMPLEX array, dimension (M)

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA

       Further Details:

             The factorization is obtained by Householder's method.  The kth
             transformation matrix, Z( k ), which is used to introduce zeros into
             the ( m - k + 1 )th row of A, is given in the form

                Z( k ) = ( I     0   ),
                         ( 0  T( k ) )

             where

                T( k ) = I - tau*u( k )*u( k )**H,   u( k ) = (   1    ),
                                                            (   0    )
                                                            ( z( k ) )

             tau is a scalar and z( k ) is an l element vector. tau and z( k )
             are chosen to annihilate the elements of the kth row of A2.

             The scalar tau is returned in the kth element of TAU and the vector
             u( k ) in the kth row of A2, such that the elements of z( k ) are
             in  a( k, l + 1 ), ..., a( k, n ). The elements of R are returned in
             the upper triangular part of A1.

             Z is given by

                Z =  Z( 1 ) * Z( 2 ) * ... * Z( m ).

   subroutine cpbcon (character UPLO, integer N, integer KD, complex, dimension( ldab, * ) AB,
       integer LDAB, real ANORM, real RCOND, complex, dimension( * ) WORK, real, dimension( * )
       RWORK, integer INFO)
       CPBCON

       Purpose:

            CPBCON estimates the reciprocal of the condition number (in the
            1-norm) of a complex Hermitian positive definite band matrix using
            the Cholesky factorization A = U**H*U or A = L*L**H computed by
            CPBTRF.

            An estimate is obtained for norm(inv(A)), and the reciprocal of the
            condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangular factor stored in AB;
                     = 'L':  Lower triangular factor stored in AB.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           KD

                     KD is INTEGER
                     The number of superdiagonals of the matrix A if UPLO = 'U',
                     or the number of sub-diagonals if UPLO = 'L'.  KD >= 0.

           AB

                     AB is COMPLEX array, dimension (LDAB,N)
                     The triangular factor U or L from the Cholesky factorization
                     A = U**H*U or A = L*L**H of the band matrix A, stored in the
                     first KD+1 rows of the array.  The j-th column of U or L is
                     stored in the j-th column of the array AB as follows:
                     if UPLO ='U', AB(kd+1+i-j,j) = U(i,j) for max(1,j-kd)<=i<=j;
                     if UPLO ='L', AB(1+i-j,j)    = L(i,j) for j<=i<=min(n,j+kd).

           LDAB

                     LDAB is INTEGER
                     The leading dimension of the array AB.  LDAB >= KD+1.

           ANORM

                     ANORM is REAL
                     The 1-norm (or infinity-norm) of the Hermitian band matrix A.

           RCOND

                     RCOND is REAL
                     The reciprocal of the condition number of the matrix A,
                     computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an
                     estimate of the 1-norm of inv(A) computed in this routine.

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cpbequ (character UPLO, integer N, integer KD, complex, dimension( ldab, * ) AB,
       integer LDAB, real, dimension( * ) S, real SCOND, real AMAX, integer INFO)
       CPBEQU

       Purpose:

            CPBEQU computes row and column scalings intended to equilibrate a
            Hermitian positive definite band matrix A and reduce its condition
            number (with respect to the two-norm).  S contains the scale factors,
            S(i) = 1/sqrt(A(i,i)), chosen so that the scaled matrix B with
            elements B(i,j) = S(i)*A(i,j)*S(j) has ones on the diagonal.  This
            choice of S puts the condition number of B within a factor N of the
            smallest possible condition number over all possible diagonal
            scalings.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangular of A is stored;
                     = 'L':  Lower triangular of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           KD

                     KD is INTEGER
                     The number of superdiagonals of the matrix A if UPLO = 'U',
                     or the number of subdiagonals if UPLO = 'L'.  KD >= 0.

           AB

                     AB is COMPLEX array, dimension (LDAB,N)
                     The upper or lower triangle of the Hermitian band matrix A,
                     stored in the first KD+1 rows of the array.  The j-th column
                     of A is stored in the j-th column of the array AB as follows:
                     if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
                     if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).

           LDAB

                     LDAB is INTEGER
                     The leading dimension of the array A.  LDAB >= KD+1.

           S

                     S is REAL array, dimension (N)
                     If INFO = 0, S contains the scale factors for A.

           SCOND

                     SCOND is REAL
                     If INFO = 0, S contains the ratio of the smallest S(i) to
                     the largest S(i).  If SCOND >= 0.1 and AMAX is neither too
                     large nor too small, it is not worth scaling by S.

           AMAX

                     AMAX is REAL
                     Absolute value of largest matrix element.  If AMAX is very
                     close to overflow or very close to underflow, the matrix
                     should be scaled.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  if INFO = i, the i-th diagonal element is nonpositive.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cpbrfs (character UPLO, integer N, integer KD, integer NRHS, complex, dimension(
       ldab, * ) AB, integer LDAB, complex, dimension( ldafb, * ) AFB, integer LDAFB, complex,
       dimension( ldb, * ) B, integer LDB, complex, dimension( ldx, * ) X, integer LDX, real,
       dimension( * ) FERR, real, dimension( * ) BERR, complex, dimension( * ) WORK, real,
       dimension( * ) RWORK, integer INFO)
       CPBRFS

       Purpose:

            CPBRFS improves the computed solution to a system of linear
            equations when the coefficient matrix is Hermitian positive definite
            and banded, and provides error bounds and backward error estimates
            for the solution.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           KD

                     KD is INTEGER
                     The number of superdiagonals of the matrix A if UPLO = 'U',
                     or the number of subdiagonals if UPLO = 'L'.  KD >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrices B and X.  NRHS >= 0.

           AB

                     AB is COMPLEX array, dimension (LDAB,N)
                     The upper or lower triangle of the Hermitian band matrix A,
                     stored in the first KD+1 rows of the array.  The j-th column
                     of A is stored in the j-th column of the array AB as follows:
                     if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
                     if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).

           LDAB

                     LDAB is INTEGER
                     The leading dimension of the array AB.  LDAB >= KD+1.

           AFB

                     AFB is COMPLEX array, dimension (LDAFB,N)
                     The triangular factor U or L from the Cholesky factorization
                     A = U**H*U or A = L*L**H of the band matrix A as computed by
                     CPBTRF, in the same storage format as A (see AB).

           LDAFB

                     LDAFB is INTEGER
                     The leading dimension of the array AFB.  LDAFB >= KD+1.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     The right hand side matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           X

                     X is COMPLEX array, dimension (LDX,NRHS)
                     On entry, the solution matrix X, as computed by CPBTRS.
                     On exit, the improved solution matrix X.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  LDX >= max(1,N).

           FERR

                     FERR is REAL array, dimension (NRHS)
                     The estimated forward error bound for each solution vector
                     X(j) (the j-th column of the solution matrix X).
                     If XTRUE is the true solution corresponding to X(j), FERR(j)
                     is an estimated upper bound for the magnitude of the largest
                     element in (X(j) - XTRUE) divided by the magnitude of the
                     largest element in X(j).  The estimate is as reliable as
                     the estimate for RCOND, and is almost always a slight
                     overestimate of the true error.

           BERR

                     BERR is REAL array, dimension (NRHS)
                     The componentwise relative backward error of each solution
                     vector X(j) (i.e., the smallest relative change in
                     any element of A or B that makes X(j) an exact solution).

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Internal Parameters:

             ITMAX is the maximum number of steps of iterative refinement.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cpbstf (character UPLO, integer N, integer KD, complex, dimension( ldab, * ) AB,
       integer LDAB, integer INFO)
       CPBSTF

       Purpose:

            CPBSTF computes a split Cholesky factorization of a complex
            Hermitian positive definite band matrix A.

            This routine is designed to be used in conjunction with CHBGST.

            The factorization has the form  A = S**H*S  where S is a band matrix
            of the same bandwidth as A and the following structure:

              S = ( U    )
                  ( M  L )

            where U is upper triangular of order m = (n+kd)/2, and L is lower
            triangular of order n-m.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           KD

                     KD is INTEGER
                     The number of superdiagonals of the matrix A if UPLO = 'U',
                     or the number of subdiagonals if UPLO = 'L'.  KD >= 0.

           AB

                     AB is COMPLEX array, dimension (LDAB,N)
                     On entry, the upper or lower triangle of the Hermitian band
                     matrix A, stored in the first kd+1 rows of the array.  The
                     j-th column of A is stored in the j-th column of the array AB
                     as follows:
                     if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
                     if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).

                     On exit, if INFO = 0, the factor S from the split Cholesky
                     factorization A = S**H*S. See Further Details.

           LDAB

                     LDAB is INTEGER
                     The leading dimension of the array AB.  LDAB >= KD+1.

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value
                     > 0: if INFO = i, the factorization could not be completed,
                          because the updated element a(i,i) was negative; the
                          matrix A is not positive definite.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The band storage scheme is illustrated by the following example, when
             N = 7, KD = 2:

             S = ( s11  s12  s13                     )
                 (      s22  s23  s24                )
                 (           s33  s34                )
                 (                s44                )
                 (           s53  s54  s55           )
                 (                s64  s65  s66      )
                 (                     s75  s76  s77 )

             If UPLO = 'U', the array AB holds:

             on entry:                          on exit:

              *    *   a13  a24  a35  a46  a57   *    *   s13  s24  s53**H s64**H s75**H
              *   a12  a23  a34  a45  a56  a67   *   s12  s23  s34  s54**H s65**H s76**H
             a11  a22  a33  a44  a55  a66  a77  s11  s22  s33  s44  s55    s66    s77

             If UPLO = 'L', the array AB holds:

             on entry:                          on exit:

             a11  a22  a33  a44  a55  a66  a77  s11    s22    s33    s44  s55  s66  s77
             a21  a32  a43  a54  a65  a76   *   s12**H s23**H s34**H s54  s65  s76   *
             a31  a42  a53  a64  a64   *    *   s13**H s24**H s53    s64  s75   *    *

             Array elements marked * are not used by the routine; s12**H denotes
             conjg(s12); the diagonal elements of S are real.

   subroutine cpbtf2 (character UPLO, integer N, integer KD, complex, dimension( ldab, * ) AB,
       integer LDAB, integer INFO)
       CPBTF2 computes the Cholesky factorization of a symmetric/Hermitian positive definite band
       matrix (unblocked algorithm).

       Purpose:

            CPBTF2 computes the Cholesky factorization of a complex Hermitian
            positive definite band matrix A.

            The factorization has the form
               A = U**H * U ,  if UPLO = 'U', or
               A = L  * L**H,  if UPLO = 'L',
            where U is an upper triangular matrix, U**H is the conjugate transpose
            of U, and L is lower triangular.

            This is the unblocked version of the algorithm, calling Level 2 BLAS.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the upper or lower triangular part of the
                     Hermitian matrix A is stored:
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           KD

                     KD is INTEGER
                     The number of super-diagonals of the matrix A if UPLO = 'U',
                     or the number of sub-diagonals if UPLO = 'L'.  KD >= 0.

           AB

                     AB is COMPLEX array, dimension (LDAB,N)
                     On entry, the upper or lower triangle of the Hermitian band
                     matrix A, stored in the first KD+1 rows of the array.  The
                     j-th column of A is stored in the j-th column of the array AB
                     as follows:
                     if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
                     if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).

                     On exit, if INFO = 0, the triangular factor U or L from the
                     Cholesky factorization A = U**H *U or A = L*L**H of the band
                     matrix A, in the same storage format as A.

           LDAB

                     LDAB is INTEGER
                     The leading dimension of the array AB.  LDAB >= KD+1.

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -k, the k-th argument had an illegal value
                     > 0: if INFO = k, the leading minor of order k is not
                          positive definite, and the factorization could not be
                          completed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The band storage scheme is illustrated by the following example, when
             N = 6, KD = 2, and UPLO = 'U':

             On entry:                       On exit:

                 *    *   a13  a24  a35  a46      *    *   u13  u24  u35  u46
                 *   a12  a23  a34  a45  a56      *   u12  u23  u34  u45  u56
                a11  a22  a33  a44  a55  a66     u11  u22  u33  u44  u55  u66

             Similarly, if UPLO = 'L' the format of A is as follows:

             On entry:                       On exit:

                a11  a22  a33  a44  a55  a66     l11  l22  l33  l44  l55  l66
                a21  a32  a43  a54  a65   *      l21  l32  l43  l54  l65   *
                a31  a42  a53  a64   *    *      l31  l42  l53  l64   *    *

             Array elements marked * are not used by the routine.

   subroutine cpbtrf (character UPLO, integer N, integer KD, complex, dimension( ldab, * ) AB,
       integer LDAB, integer INFO)
       CPBTRF

       Purpose:

            CPBTRF computes the Cholesky factorization of a complex Hermitian
            positive definite band matrix A.

            The factorization has the form
               A = U**H * U,  if UPLO = 'U', or
               A = L  * L**H,  if UPLO = 'L',
            where U is an upper triangular matrix and L is lower triangular.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           KD

                     KD is INTEGER
                     The number of superdiagonals of the matrix A if UPLO = 'U',
                     or the number of subdiagonals if UPLO = 'L'.  KD >= 0.

           AB

                     AB is COMPLEX array, dimension (LDAB,N)
                     On entry, the upper or lower triangle of the Hermitian band
                     matrix A, stored in the first KD+1 rows of the array.  The
                     j-th column of A is stored in the j-th column of the array AB
                     as follows:
                     if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
                     if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).

                     On exit, if INFO = 0, the triangular factor U or L from the
                     Cholesky factorization A = U**H*U or A = L*L**H of the band
                     matrix A, in the same storage format as A.

           LDAB

                     LDAB is INTEGER
                     The leading dimension of the array AB.  LDAB >= KD+1.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value
                     > 0:  if INFO = i, the leading minor of order i is not
                           positive definite, and the factorization could not be
                           completed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The band storage scheme is illustrated by the following example, when
             N = 6, KD = 2, and UPLO = 'U':

             On entry:                       On exit:

                 *    *   a13  a24  a35  a46      *    *   u13  u24  u35  u46
                 *   a12  a23  a34  a45  a56      *   u12  u23  u34  u45  u56
                a11  a22  a33  a44  a55  a66     u11  u22  u33  u44  u55  u66

             Similarly, if UPLO = 'L' the format of A is as follows:

             On entry:                       On exit:

                a11  a22  a33  a44  a55  a66     l11  l22  l33  l44  l55  l66
                a21  a32  a43  a54  a65   *      l21  l32  l43  l54  l65   *
                a31  a42  a53  a64   *    *      l31  l42  l53  l64   *    *

             Array elements marked * are not used by the routine.

       Contributors:
           Peter Mayes and Giuseppe Radicati, IBM ECSEC, Rome, March 23, 1989

   subroutine cpbtrs (character UPLO, integer N, integer KD, integer NRHS, complex, dimension(
       ldab, * ) AB, integer LDAB, complex, dimension( ldb, * ) B, integer LDB, integer INFO)
       CPBTRS

       Purpose:

            CPBTRS solves a system of linear equations A*X = B with a Hermitian
            positive definite band matrix A using the Cholesky factorization
            A = U**H*U or A = L*L**H computed by CPBTRF.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangular factor stored in AB;
                     = 'L':  Lower triangular factor stored in AB.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           KD

                     KD is INTEGER
                     The number of superdiagonals of the matrix A if UPLO = 'U',
                     or the number of subdiagonals if UPLO = 'L'.  KD >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrix B.  NRHS >= 0.

           AB

                     AB is COMPLEX array, dimension (LDAB,N)
                     The triangular factor U or L from the Cholesky factorization
                     A = U**H*U or A = L*L**H of the band matrix A, stored in the
                     first KD+1 rows of the array.  The j-th column of U or L is
                     stored in the j-th column of the array AB as follows:
                     if UPLO ='U', AB(kd+1+i-j,j) = U(i,j) for max(1,j-kd)<=i<=j;
                     if UPLO ='L', AB(1+i-j,j)    = L(i,j) for j<=i<=min(n,j+kd).

           LDAB

                     LDAB is INTEGER
                     The leading dimension of the array AB.  LDAB >= KD+1.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     On entry, the right hand side matrix B.
                     On exit, the solution matrix X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cpftrf (character TRANSR, character UPLO, integer N, complex, dimension( 0: * ) A,
       integer INFO)
       CPFTRF

       Purpose:

            CPFTRF computes the Cholesky factorization of a complex Hermitian
            positive definite matrix A.

            The factorization has the form
               A = U**H * U,  if UPLO = 'U', or
               A = L  * L**H,  if UPLO = 'L',
            where U is an upper triangular matrix and L is lower triangular.

            This is the block version of the algorithm, calling Level 3 BLAS.

       Parameters
           TRANSR

                     TRANSR is CHARACTER*1
                     = 'N':  The Normal TRANSR of RFP A is stored;
                     = 'C':  The Conjugate-transpose TRANSR of RFP A is stored.

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of RFP A is stored;
                     = 'L':  Lower triangle of RFP A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           A

                     A is COMPLEX array, dimension ( N*(N+1)/2 );
                     On entry, the Hermitian matrix A in RFP format. RFP format is
                     described by TRANSR, UPLO, and N as follows: If TRANSR = 'N'
                     then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is
                     (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'C' then RFP is
                     the Conjugate-transpose of RFP A as defined when
                     TRANSR = 'N'. The contents of RFP A are defined by UPLO as
                     follows: If UPLO = 'U' the RFP A contains the nt elements of
                     upper packed A. If UPLO = 'L' the RFP A contains the elements
                     of lower packed A. The LDA of RFP A is (N+1)/2 when TRANSR =
                     'C'. When TRANSR is 'N' the LDA is N+1 when N is even and N
                     is odd. See the Note below for more details.

                     On exit, if INFO = 0, the factor U or L from the Cholesky
                     factorization RFP A = U**H*U or RFP A = L*L**H.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value
                     > 0:  if INFO = i, the leading minor of order i is not
                           positive definite, and the factorization could not be
                           completed.

             Further Notes on RFP Format:
             ============================

             We first consider Standard Packed Format when N is even.
             We give an example where N = 6.

                AP is Upper             AP is Lower

              00 01 02 03 04 05       00
                 11 12 13 14 15       10 11
                    22 23 24 25       20 21 22
                       33 34 35       30 31 32 33
                          44 45       40 41 42 43 44
                             55       50 51 52 53 54 55

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last
             three columns of AP upper. The lower triangle A(4:6,0:2) consists of
             conjugate-transpose of the first three columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:2,0:2) consists of
             conjugate-transpose of the last three columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N even and TRANSR = 'N'.

                    RFP A                   RFP A

                                           -- -- --
                   03 04 05                33 43 53
                                              -- --
                   13 14 15                00 44 54
                                                 --
                   23 24 25                10 11 55

                   33 34 35                20 21 22
                   --
                   00 44 45                30 31 32
                   -- --
                   01 11 55                40 41 42
                   -- -- --
                   02 12 22                50 51 52

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- -- --                -- -- -- -- -- --
                03 13 23 33 00 01 02    33 00 10 20 30 40 50
                -- -- -- -- --                -- -- -- -- --
                04 14 24 34 44 11 12    43 44 11 21 31 41 51
                -- -- -- -- -- --                -- -- -- --
                05 15 25 35 45 55 22    53 54 55 22 32 42 52

             We next  consider Standard Packed Format when N is odd.
             We give an example where N = 5.

                AP is Upper                 AP is Lower

              00 01 02 03 04              00
                 11 12 13 14              10 11
                    22 23 24              20 21 22
                       33 34              30 31 32 33
                          44              40 41 42 43 44

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last
             three columns of AP upper. The lower triangle A(3:4,0:1) consists of
             conjugate-transpose of the first two   columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:1,1:2) consists of
             conjugate-transpose of the last two   columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N odd  and TRANSR = 'N'.

                    RFP A                   RFP A

                                              -- --
                   02 03 04                00 33 43
                                                 --
                   12 13 14                10 11 44

                   22 23 24                20 21 22
                   --
                   00 33 34                30 31 32
                   -- --
                   01 11 44                40 41 42

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- --                   -- -- -- -- -- --
                02 12 22 00 01             00 10 20 30 40 50
                -- -- -- --                   -- -- -- -- --
                03 13 23 33 11             33 11 21 31 41 51
                -- -- -- -- --                   -- -- -- --
                04 14 24 34 44             43 44 22 32 42 52

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cpftri (character TRANSR, character UPLO, integer N, complex, dimension( 0: * ) A,
       integer INFO)
       CPFTRI

       Purpose:

            CPFTRI computes the inverse of a complex Hermitian positive definite
            matrix A using the Cholesky factorization A = U**H*U or A = L*L**H
            computed by CPFTRF.

       Parameters
           TRANSR

                     TRANSR is CHARACTER*1
                     = 'N':  The Normal TRANSR of RFP A is stored;
                     = 'C':  The Conjugate-transpose TRANSR of RFP A is stored.

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           A

                     A is COMPLEX array, dimension ( N*(N+1)/2 );
                     On entry, the Hermitian matrix A in RFP format. RFP format is
                     described by TRANSR, UPLO, and N as follows: If TRANSR = 'N'
                     then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is
                     (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'C' then RFP is
                     the Conjugate-transpose of RFP A as defined when
                     TRANSR = 'N'. The contents of RFP A are defined by UPLO as
                     follows: If UPLO = 'U' the RFP A contains the nt elements of
                     upper packed A. If UPLO = 'L' the RFP A contains the elements
                     of lower packed A. The LDA of RFP A is (N+1)/2 when TRANSR =
                     'C'. When TRANSR is 'N' the LDA is N+1 when N is even and N
                     is odd. See the Note below for more details.

                     On exit, the Hermitian inverse of the original matrix, in the
                     same storage format.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value
                     > 0:  if INFO = i, the (i,i) element of the factor U or L is
                           zero, and the inverse could not be computed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             We first consider Standard Packed Format when N is even.
             We give an example where N = 6.

                 AP is Upper             AP is Lower

              00 01 02 03 04 05       00
                 11 12 13 14 15       10 11
                    22 23 24 25       20 21 22
                       33 34 35       30 31 32 33
                          44 45       40 41 42 43 44
                             55       50 51 52 53 54 55

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last
             three columns of AP upper. The lower triangle A(4:6,0:2) consists of
             conjugate-transpose of the first three columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:2,0:2) consists of
             conjugate-transpose of the last three columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N even and TRANSR = 'N'.

                    RFP A                   RFP A

                                           -- -- --
                   03 04 05                33 43 53
                                              -- --
                   13 14 15                00 44 54
                                                 --
                   23 24 25                10 11 55

                   33 34 35                20 21 22
                   --
                   00 44 45                30 31 32
                   -- --
                   01 11 55                40 41 42
                   -- -- --
                   02 12 22                50 51 52

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- -- --                -- -- -- -- -- --
                03 13 23 33 00 01 02    33 00 10 20 30 40 50
                -- -- -- -- --                -- -- -- -- --
                04 14 24 34 44 11 12    43 44 11 21 31 41 51
                -- -- -- -- -- --                -- -- -- --
                05 15 25 35 45 55 22    53 54 55 22 32 42 52

             We next  consider Standard Packed Format when N is odd.
             We give an example where N = 5.

                AP is Upper                 AP is Lower

              00 01 02 03 04              00
                 11 12 13 14              10 11
                    22 23 24              20 21 22
                       33 34              30 31 32 33
                          44              40 41 42 43 44

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last
             three columns of AP upper. The lower triangle A(3:4,0:1) consists of
             conjugate-transpose of the first two   columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:1,1:2) consists of
             conjugate-transpose of the last two   columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N odd  and TRANSR = 'N'.

                    RFP A                   RFP A

                                              -- --
                   02 03 04                00 33 43
                                                 --
                   12 13 14                10 11 44

                   22 23 24                20 21 22
                   --
                   00 33 34                30 31 32
                   -- --
                   01 11 44                40 41 42

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- --                   -- -- -- -- -- --
                02 12 22 00 01             00 10 20 30 40 50
                -- -- -- --                   -- -- -- -- --
                03 13 23 33 11             33 11 21 31 41 51
                -- -- -- -- --                   -- -- -- --
                04 14 24 34 44             43 44 22 32 42 52

   subroutine cpftrs (character TRANSR, character UPLO, integer N, integer NRHS, complex,
       dimension( 0: * ) A, complex, dimension( ldb, * ) B, integer LDB, integer INFO)
       CPFTRS

       Purpose:

            CPFTRS solves a system of linear equations A*X = B with a Hermitian
            positive definite matrix A using the Cholesky factorization
            A = U**H*U or A = L*L**H computed by CPFTRF.

       Parameters
           TRANSR

                     TRANSR is CHARACTER*1
                     = 'N':  The Normal TRANSR of RFP A is stored;
                     = 'C':  The Conjugate-transpose TRANSR of RFP A is stored.

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of RFP A is stored;
                     = 'L':  Lower triangle of RFP A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrix B.  NRHS >= 0.

           A

                     A is COMPLEX array, dimension ( N*(N+1)/2 );
                     The triangular factor U or L from the Cholesky factorization
                     of RFP A = U**H*U or RFP A = L*L**H, as computed by CPFTRF.
                     See note below for more details about RFP A.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     On entry, the right hand side matrix B.
                     On exit, the solution matrix X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             We first consider Standard Packed Format when N is even.
             We give an example where N = 6.

                 AP is Upper             AP is Lower

              00 01 02 03 04 05       00
                 11 12 13 14 15       10 11
                    22 23 24 25       20 21 22
                       33 34 35       30 31 32 33
                          44 45       40 41 42 43 44
                             55       50 51 52 53 54 55

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last
             three columns of AP upper. The lower triangle A(4:6,0:2) consists of
             conjugate-transpose of the first three columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:2,0:2) consists of
             conjugate-transpose of the last three columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N even and TRANSR = 'N'.

                    RFP A                   RFP A

                                           -- -- --
                   03 04 05                33 43 53
                                              -- --
                   13 14 15                00 44 54
                                                 --
                   23 24 25                10 11 55

                   33 34 35                20 21 22
                   --
                   00 44 45                30 31 32
                   -- --
                   01 11 55                40 41 42
                   -- -- --
                   02 12 22                50 51 52

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- -- --                -- -- -- -- -- --
                03 13 23 33 00 01 02    33 00 10 20 30 40 50
                -- -- -- -- --                -- -- -- -- --
                04 14 24 34 44 11 12    43 44 11 21 31 41 51
                -- -- -- -- -- --                -- -- -- --
                05 15 25 35 45 55 22    53 54 55 22 32 42 52

             We next  consider Standard Packed Format when N is odd.
             We give an example where N = 5.

                AP is Upper                 AP is Lower

              00 01 02 03 04              00
                 11 12 13 14              10 11
                    22 23 24              20 21 22
                       33 34              30 31 32 33
                          44              40 41 42 43 44

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last
             three columns of AP upper. The lower triangle A(3:4,0:1) consists of
             conjugate-transpose of the first two   columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:1,1:2) consists of
             conjugate-transpose of the last two   columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N odd  and TRANSR = 'N'.

                    RFP A                   RFP A

                                              -- --
                   02 03 04                00 33 43
                                                 --
                   12 13 14                10 11 44

                   22 23 24                20 21 22
                   --
                   00 33 34                30 31 32
                   -- --
                   01 11 44                40 41 42

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- --                   -- -- -- -- -- --
                02 12 22 00 01             00 10 20 30 40 50
                -- -- -- --                   -- -- -- -- --
                03 13 23 33 11             33 11 21 31 41 51
                -- -- -- -- --                   -- -- -- --
                04 14 24 34 44             43 44 22 32 42 52

   subroutine cppcon (character UPLO, integer N, complex, dimension( * ) AP, real ANORM, real
       RCOND, complex, dimension( * ) WORK, real, dimension( * ) RWORK, integer INFO)
       CPPCON

       Purpose:

            CPPCON estimates the reciprocal of the condition number (in the
            1-norm) of a complex Hermitian positive definite packed matrix using
            the Cholesky factorization A = U**H*U or A = L*L**H computed by
            CPPTRF.

            An estimate is obtained for norm(inv(A)), and the reciprocal of the
            condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The triangular factor U or L from the Cholesky factorization
                     A = U**H*U or A = L*L**H, packed columnwise in a linear
                     array.  The j-th column of U or L is stored in the array AP
                     as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n.

           ANORM

                     ANORM is REAL
                     The 1-norm (or infinity-norm) of the Hermitian matrix A.

           RCOND

                     RCOND is REAL
                     The reciprocal of the condition number of the matrix A,
                     computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an
                     estimate of the 1-norm of inv(A) computed in this routine.

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cppequ (character UPLO, integer N, complex, dimension( * ) AP, real, dimension( * )
       S, real SCOND, real AMAX, integer INFO)
       CPPEQU

       Purpose:

            CPPEQU computes row and column scalings intended to equilibrate a
            Hermitian positive definite matrix A in packed storage and reduce
            its condition number (with respect to the two-norm).  S contains the
            scale factors, S(i)=1/sqrt(A(i,i)), chosen so that the scaled matrix
            B with elements B(i,j)=S(i)*A(i,j)*S(j) has ones on the diagonal.
            This choice of S puts the condition number of B within a factor N of
            the smallest possible condition number over all possible diagonal
            scalings.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The upper or lower triangle of the Hermitian matrix A, packed
                     columnwise in a linear array.  The j-th column of A is stored
                     in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

           S

                     S is REAL array, dimension (N)
                     If INFO = 0, S contains the scale factors for A.

           SCOND

                     SCOND is REAL
                     If INFO = 0, S contains the ratio of the smallest S(i) to
                     the largest S(i).  If SCOND >= 0.1 and AMAX is neither too
                     large nor too small, it is not worth scaling by S.

           AMAX

                     AMAX is REAL
                     Absolute value of largest matrix element.  If AMAX is very
                     close to overflow or very close to underflow, the matrix
                     should be scaled.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value
                     > 0:  if INFO = i, the i-th diagonal element is nonpositive.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cpprfs (character UPLO, integer N, integer NRHS, complex, dimension( * ) AP,
       complex, dimension( * ) AFP, complex, dimension( ldb, * ) B, integer LDB, complex,
       dimension( ldx, * ) X, integer LDX, real, dimension( * ) FERR, real, dimension( * ) BERR,
       complex, dimension( * ) WORK, real, dimension( * ) RWORK, integer INFO)
       CPPRFS

       Purpose:

            CPPRFS improves the computed solution to a system of linear
            equations when the coefficient matrix is Hermitian positive definite
            and packed, and provides error bounds and backward error estimates
            for the solution.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrices B and X.  NRHS >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The upper or lower triangle of the Hermitian matrix A, packed
                     columnwise in a linear array.  The j-th column of A is stored
                     in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

           AFP

                     AFP is COMPLEX array, dimension (N*(N+1)/2)
                     The triangular factor U or L from the Cholesky factorization
                     A = U**H*U or A = L*L**H, as computed by SPPTRF/CPPTRF,
                     packed columnwise in a linear array in the same format as A
                     (see AP).

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     The right hand side matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           X

                     X is COMPLEX array, dimension (LDX,NRHS)
                     On entry, the solution matrix X, as computed by CPPTRS.
                     On exit, the improved solution matrix X.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  LDX >= max(1,N).

           FERR

                     FERR is REAL array, dimension (NRHS)
                     The estimated forward error bound for each solution vector
                     X(j) (the j-th column of the solution matrix X).
                     If XTRUE is the true solution corresponding to X(j), FERR(j)
                     is an estimated upper bound for the magnitude of the largest
                     element in (X(j) - XTRUE) divided by the magnitude of the
                     largest element in X(j).  The estimate is as reliable as
                     the estimate for RCOND, and is almost always a slight
                     overestimate of the true error.

           BERR

                     BERR is REAL array, dimension (NRHS)
                     The componentwise relative backward error of each solution
                     vector X(j) (i.e., the smallest relative change in
                     any element of A or B that makes X(j) an exact solution).

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Internal Parameters:

             ITMAX is the maximum number of steps of iterative refinement.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cpptrf (character UPLO, integer N, complex, dimension( * ) AP, integer INFO)
       CPPTRF

       Purpose:

            CPPTRF computes the Cholesky factorization of a complex Hermitian
            positive definite matrix A stored in packed format.

            The factorization has the form
               A = U**H * U,  if UPLO = 'U', or
               A = L  * L**H,  if UPLO = 'L',
            where U is an upper triangular matrix and L is lower triangular.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     On entry, the upper or lower triangle of the Hermitian matrix
                     A, packed columnwise in a linear array.  The j-th column of A
                     is stored in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
                     See below for further details.

                     On exit, if INFO = 0, the triangular factor U or L from the
                     Cholesky factorization A = U**H*U or A = L*L**H, in the same
                     storage format as A.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value
                     > 0:  if INFO = i, the leading minor of order i is not
                           positive definite, and the factorization could not be
                           completed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The packed storage scheme is illustrated by the following example
             when N = 4, UPLO = 'U':

             Two-dimensional storage of the Hermitian matrix A:

                a11 a12 a13 a14
                    a22 a23 a24
                        a33 a34     (aij = conjg(aji))
                            a44

             Packed storage of the upper triangle of A:

             AP = [ a11, a12, a22, a13, a23, a33, a14, a24, a34, a44 ]

   subroutine cpptri (character UPLO, integer N, complex, dimension( * ) AP, integer INFO)
       CPPTRI

       Purpose:

            CPPTRI computes the inverse of a complex Hermitian positive definite
            matrix A using the Cholesky factorization A = U**H*U or A = L*L**H
            computed by CPPTRF.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangular factor is stored in AP;
                     = 'L':  Lower triangular factor is stored in AP.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     On entry, the triangular factor U or L from the Cholesky
                     factorization A = U**H*U or A = L*L**H, packed columnwise as
                     a linear array.  The j-th column of U or L is stored in the
                     array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n.

                     On exit, the upper or lower triangle of the (Hermitian)
                     inverse of A, overwriting the input factor U or L.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value
                     > 0:  if INFO = i, the (i,i) element of the factor U or L is
                           zero, and the inverse could not be computed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cpptrs (character UPLO, integer N, integer NRHS, complex, dimension( * ) AP,
       complex, dimension( ldb, * ) B, integer LDB, integer INFO)
       CPPTRS

       Purpose:

            CPPTRS solves a system of linear equations A*X = B with a Hermitian
            positive definite matrix A in packed storage using the Cholesky
            factorization A = U**H*U or A = L*L**H computed by CPPTRF.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrix B.  NRHS >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The triangular factor U or L from the Cholesky factorization
                     A = U**H*U or A = L*L**H, packed columnwise in a linear
                     array.  The j-th column of U or L is stored in the array AP
                     as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = U(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = L(i,j) for j<=i<=n.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     On entry, the right hand side matrix B.
                     On exit, the solution matrix X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cpstf2 (character UPLO, integer N, complex, dimension( lda, * ) A, integer LDA,
       integer, dimension( n ) PIV, integer RANK, real TOL, real, dimension( 2*n ) WORK, integer
       INFO)
       CPSTF2 computes the Cholesky factorization with complete pivoting of complex Hermitian
       positive semidefinite matrix.

       Purpose:

            CPSTF2 computes the Cholesky factorization with complete
            pivoting of a complex Hermitian positive semidefinite matrix A.

            The factorization has the form
               P**T * A * P = U**H * U ,  if UPLO = 'U',
               P**T * A * P = L  * L**H,  if UPLO = 'L',
            where U is an upper triangular matrix and L is lower triangular, and
            P is stored as vector PIV.

            This algorithm does not attempt to check that A is positive
            semidefinite. This version of the algorithm calls level 2 BLAS.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the upper or lower triangular part of the
                     symmetric matrix A is stored.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the symmetric matrix A.  If UPLO = 'U', the leading
                     n by n upper triangular part of A contains the upper
                     triangular part of the matrix A, and the strictly lower
                     triangular part of A is not referenced.  If UPLO = 'L', the
                     leading n by n lower triangular part of A contains the lower
                     triangular part of the matrix A, and the strictly upper
                     triangular part of A is not referenced.

                     On exit, if INFO = 0, the factor U or L from the Cholesky
                     factorization as above.

           PIV

                     PIV is INTEGER array, dimension (N)
                     PIV is such that the nonzero entries are P( PIV(K), K ) = 1.

           RANK

                     RANK is INTEGER
                     The rank of A given by the number of steps the algorithm
                     completed.

           TOL

                     TOL is REAL
                     User defined tolerance. If TOL < 0, then N*U*MAX( A( K,K ) )
                     will be used. The algorithm terminates at the (K-1)st step
                     if the pivot <= TOL.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           WORK

                     WORK is REAL array, dimension (2*N)
                     Work space.

           INFO

                     INFO is INTEGER
                     < 0: If INFO = -K, the K-th argument had an illegal value,
                     = 0: algorithm completed successfully, and
                     > 0: the matrix A is either rank deficient with computed rank
                          as returned in RANK, or is not positive semidefinite. See
                          Section 7 of LAPACK Working Note #161 for further
                          information.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cpstrf (character UPLO, integer N, complex, dimension( lda, * ) A, integer LDA,
       integer, dimension( n ) PIV, integer RANK, real TOL, real, dimension( 2*n ) WORK, integer
       INFO)
       CPSTRF computes the Cholesky factorization with complete pivoting of complex Hermitian
       positive semidefinite matrix.

       Purpose:

            CPSTRF computes the Cholesky factorization with complete
            pivoting of a complex Hermitian positive semidefinite matrix A.

            The factorization has the form
               P**T * A * P = U**H * U ,  if UPLO = 'U',
               P**T * A * P = L  * L**H,  if UPLO = 'L',
            where U is an upper triangular matrix and L is lower triangular, and
            P is stored as vector PIV.

            This algorithm does not attempt to check that A is positive
            semidefinite. This version of the algorithm calls level 3 BLAS.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the upper or lower triangular part of the
                     symmetric matrix A is stored.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the symmetric matrix A.  If UPLO = 'U', the leading
                     n by n upper triangular part of A contains the upper
                     triangular part of the matrix A, and the strictly lower
                     triangular part of A is not referenced.  If UPLO = 'L', the
                     leading n by n lower triangular part of A contains the lower
                     triangular part of the matrix A, and the strictly upper
                     triangular part of A is not referenced.

                     On exit, if INFO = 0, the factor U or L from the Cholesky
                     factorization as above.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           PIV

                     PIV is INTEGER array, dimension (N)
                     PIV is such that the nonzero entries are P( PIV(K), K ) = 1.

           RANK

                     RANK is INTEGER
                     The rank of A given by the number of steps the algorithm
                     completed.

           TOL

                     TOL is REAL
                     User defined tolerance. If TOL < 0, then N*U*MAX( A(K,K) )
                     will be used. The algorithm terminates at the (K-1)st step
                     if the pivot <= TOL.

           WORK

                     WORK is REAL array, dimension (2*N)
                     Work space.

           INFO

                     INFO is INTEGER
                     < 0: If INFO = -K, the K-th argument had an illegal value,
                     = 0: algorithm completed successfully, and
                     > 0: the matrix A is either rank deficient with computed rank
                          as returned in RANK, or is not positive semidefinite. See
                          Section 7 of LAPACK Working Note #161 for further
                          information.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cspcon (character UPLO, integer N, complex, dimension( * ) AP, integer, dimension(
       * ) IPIV, real ANORM, real RCOND, complex, dimension( * ) WORK, integer INFO)
       CSPCON

       Purpose:

            CSPCON estimates the reciprocal of the condition number (in the
            1-norm) of a complex symmetric packed matrix A using the
            factorization A = U*D*U**T or A = L*D*L**T computed by CSPTRF.

            An estimate is obtained for norm(inv(A)), and the reciprocal of the
            condition number is computed as RCOND = 1 / (ANORM * norm(inv(A))).

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the details of the factorization are stored
                     as an upper or lower triangular matrix.
                     = 'U':  Upper triangular, form is A = U*D*U**T;
                     = 'L':  Lower triangular, form is A = L*D*L**T.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The block diagonal matrix D and the multipliers used to
                     obtain the factor U or L as computed by CSPTRF, stored as a
                     packed triangular matrix.

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by CSPTRF.

           ANORM

                     ANORM is REAL
                     The 1-norm of the original matrix A.

           RCOND

                     RCOND is REAL
                     The reciprocal of the condition number of the matrix A,
                     computed as RCOND = 1/(ANORM * AINVNM), where AINVNM is an
                     estimate of the 1-norm of inv(A) computed in this routine.

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine csprfs (character UPLO, integer N, integer NRHS, complex, dimension( * ) AP,
       complex, dimension( * ) AFP, integer, dimension( * ) IPIV, complex, dimension( ldb, * ) B,
       integer LDB, complex, dimension( ldx, * ) X, integer LDX, real, dimension( * ) FERR, real,
       dimension( * ) BERR, complex, dimension( * ) WORK, real, dimension( * ) RWORK, integer
       INFO)
       CSPRFS

       Purpose:

            CSPRFS improves the computed solution to a system of linear
            equations when the coefficient matrix is symmetric indefinite
            and packed, and provides error bounds and backward error estimates
            for the solution.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrices B and X.  NRHS >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The upper or lower triangle of the symmetric matrix A, packed
                     columnwise in a linear array.  The j-th column of A is stored
                     in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.

           AFP

                     AFP is COMPLEX array, dimension (N*(N+1)/2)
                     The factored form of the matrix A.  AFP contains the block
                     diagonal matrix D and the multipliers used to obtain the
                     factor U or L from the factorization A = U*D*U**T or
                     A = L*D*L**T as computed by CSPTRF, stored as a packed
                     triangular matrix.

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by CSPTRF.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     The right hand side matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           X

                     X is COMPLEX array, dimension (LDX,NRHS)
                     On entry, the solution matrix X, as computed by CSPTRS.
                     On exit, the improved solution matrix X.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  LDX >= max(1,N).

           FERR

                     FERR is REAL array, dimension (NRHS)
                     The estimated forward error bound for each solution vector
                     X(j) (the j-th column of the solution matrix X).
                     If XTRUE is the true solution corresponding to X(j), FERR(j)
                     is an estimated upper bound for the magnitude of the largest
                     element in (X(j) - XTRUE) divided by the magnitude of the
                     largest element in X(j).  The estimate is as reliable as
                     the estimate for RCOND, and is almost always a slight
                     overestimate of the true error.

           BERR

                     BERR is REAL array, dimension (NRHS)
                     The componentwise relative backward error of each solution
                     vector X(j) (i.e., the smallest relative change in
                     any element of A or B that makes X(j) an exact solution).

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Internal Parameters:

             ITMAX is the maximum number of steps of iterative refinement.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine csptrf (character UPLO, integer N, complex, dimension( * ) AP, integer, dimension(
       * ) IPIV, integer INFO)
       CSPTRF

       Purpose:

            CSPTRF computes the factorization of a complex symmetric matrix A
            stored in packed format using the Bunch-Kaufman diagonal pivoting
            method:

               A = U*D*U**T  or  A = L*D*L**T

            where U (or L) is a product of permutation and unit upper (lower)
            triangular matrices, and D is symmetric and block diagonal with
            1-by-1 and 2-by-2 diagonal blocks.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  Upper triangle of A is stored;
                     = 'L':  Lower triangle of A is stored.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     On entry, the upper or lower triangle of the symmetric matrix
                     A, packed columnwise in a linear array.  The j-th column of A
                     is stored in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

                     On exit, the block diagonal matrix D and the multipliers used
                     to obtain the factor U or L, stored as a packed triangular
                     matrix overwriting A (see below for further details).

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D.
                     If IPIV(k) > 0, then rows and columns k and IPIV(k) were
                     interchanged and D(k,k) is a 1-by-1 diagonal block.
                     If UPLO = 'U' and IPIV(k) = IPIV(k-1) < 0, then rows and
                     columns k-1 and -IPIV(k) were interchanged and D(k-1:k,k-1:k)
                     is a 2-by-2 diagonal block.  If UPLO = 'L' and IPIV(k) =
                     IPIV(k+1) < 0, then rows and columns k+1 and -IPIV(k) were
                     interchanged and D(k:k+1,k:k+1) is a 2-by-2 diagonal block.

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value
                     > 0: if INFO = i, D(i,i) is exactly zero.  The factorization
                          has been completed, but the block diagonal matrix D is
                          exactly singular, and division by zero will occur if it
                          is used to solve a system of equations.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             5-96 - Based on modifications by J. Lewis, Boeing Computer Services
                    Company

             If UPLO = 'U', then A = U*D*U**T, where
                U = P(n)*U(n)* ... *P(k)U(k)* ...,
             i.e., U is a product of terms P(k)*U(k), where k decreases from n to
             1 in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
             and 2-by-2 diagonal blocks D(k).  P(k) is a permutation matrix as
             defined by IPIV(k), and U(k) is a unit upper triangular matrix, such
             that if the diagonal block D(k) is of order s (s = 1 or 2), then

                        (   I    v    0   )   k-s
                U(k) =  (   0    I    0   )   s
                        (   0    0    I   )   n-k
                           k-s   s   n-k

             If s = 1, D(k) overwrites A(k,k), and v overwrites A(1:k-1,k).
             If s = 2, the upper triangle of D(k) overwrites A(k-1,k-1), A(k-1,k),
             and A(k,k), and v overwrites A(1:k-2,k-1:k).

             If UPLO = 'L', then A = L*D*L**T, where
                L = P(1)*L(1)* ... *P(k)*L(k)* ...,
             i.e., L is a product of terms P(k)*L(k), where k increases from 1 to
             n in steps of 1 or 2, and D is a block diagonal matrix with 1-by-1
             and 2-by-2 diagonal blocks D(k).  P(k) is a permutation matrix as
             defined by IPIV(k), and L(k) is a unit lower triangular matrix, such
             that if the diagonal block D(k) is of order s (s = 1 or 2), then

                        (   I    0     0   )  k-1
                L(k) =  (   0    I     0   )  s
                        (   0    v     I   )  n-k-s+1
                           k-1   s  n-k-s+1

             If s = 1, D(k) overwrites A(k,k), and v overwrites A(k+1:n,k).
             If s = 2, the lower triangle of D(k) overwrites A(k,k), A(k+1,k),
             and A(k+1,k+1), and v overwrites A(k+2:n,k:k+1).

   subroutine csptri (character UPLO, integer N, complex, dimension( * ) AP, integer, dimension(
       * ) IPIV, complex, dimension( * ) WORK, integer INFO)
       CSPTRI

       Purpose:

            CSPTRI computes the inverse of a complex symmetric indefinite matrix
            A in packed storage using the factorization A = U*D*U**T or
            A = L*D*L**T computed by CSPTRF.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the details of the factorization are stored
                     as an upper or lower triangular matrix.
                     = 'U':  Upper triangular, form is A = U*D*U**T;
                     = 'L':  Lower triangular, form is A = L*D*L**T.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     On entry, the block diagonal matrix D and the multipliers
                     used to obtain the factor U or L as computed by CSPTRF,
                     stored as a packed triangular matrix.

                     On exit, if INFO = 0, the (symmetric) inverse of the original
                     matrix, stored as a packed triangular matrix. The j-th column
                     of inv(A) is stored in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = inv(A)(i,j) for 1<=i<=j;
                     if UPLO = 'L',
                        AP(i + (j-1)*(2n-j)/2) = inv(A)(i,j) for j<=i<=n.

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by CSPTRF.

           WORK

                     WORK is COMPLEX array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value
                     > 0: if INFO = i, D(i,i) = 0; the matrix is singular and its
                          inverse could not be computed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine csptrs (character UPLO, integer N, integer NRHS, complex, dimension( * ) AP,
       integer, dimension( * ) IPIV, complex, dimension( ldb, * ) B, integer LDB, integer INFO)
       CSPTRS

       Purpose:

            CSPTRS solves a system of linear equations A*X = B with a complex
            symmetric matrix A stored in packed format using the factorization
            A = U*D*U**T or A = L*D*L**T computed by CSPTRF.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the details of the factorization are stored
                     as an upper or lower triangular matrix.
                     = 'U':  Upper triangular, form is A = U*D*U**T;
                     = 'L':  Lower triangular, form is A = L*D*L**T.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrix B.  NRHS >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The block diagonal matrix D and the multipliers used to
                     obtain the factor U or L as computed by CSPTRF, stored as a
                     packed triangular matrix.

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D
                     as determined by CSPTRF.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     On entry, the right hand side matrix B.
                     On exit, the solution matrix X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cstedc (character COMPZ, integer N, real, dimension( * ) D, real, dimension( * ) E,
       complex, dimension( ldz, * ) Z, integer LDZ, complex, dimension( * ) WORK, integer LWORK,
       real, dimension( * ) RWORK, integer LRWORK, integer, dimension( * ) IWORK, integer LIWORK,
       integer INFO)
       CSTEDC

       Purpose:

            CSTEDC computes all eigenvalues and, optionally, eigenvectors of a
            symmetric tridiagonal matrix using the divide and conquer method.
            The eigenvectors of a full or band complex Hermitian matrix can also
            be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this
            matrix to tridiagonal form.

            This code makes very mild assumptions about floating point
            arithmetic. It will work on machines with a guard digit in
            add/subtract, or on those binary machines without guard digits
            which subtract like the Cray X-MP, Cray Y-MP, Cray C-90, or Cray-2.
            It could conceivably fail on hexadecimal or decimal machines
            without guard digits, but we know of none.  See SLAED3 for details.

       Parameters
           COMPZ

                     COMPZ is CHARACTER*1
                     = 'N':  Compute eigenvalues only.
                     = 'I':  Compute eigenvectors of tridiagonal matrix also.
                     = 'V':  Compute eigenvectors of original Hermitian matrix
                             also.  On entry, Z contains the unitary matrix used
                             to reduce the original matrix to tridiagonal form.

           N

                     N is INTEGER
                     The dimension of the symmetric tridiagonal matrix.  N >= 0.

           D

                     D is REAL array, dimension (N)
                     On entry, the diagonal elements of the tridiagonal matrix.
                     On exit, if INFO = 0, the eigenvalues in ascending order.

           E

                     E is REAL array, dimension (N-1)
                     On entry, the subdiagonal elements of the tridiagonal matrix.
                     On exit, E has been destroyed.

           Z

                     Z is COMPLEX array, dimension (LDZ,N)
                     On entry, if COMPZ = 'V', then Z contains the unitary
                     matrix used in the reduction to tridiagonal form.
                     On exit, if INFO = 0, then if COMPZ = 'V', Z contains the
                     orthonormal eigenvectors of the original Hermitian matrix,
                     and if COMPZ = 'I', Z contains the orthonormal eigenvectors
                     of the symmetric tridiagonal matrix.
                     If  COMPZ = 'N', then Z is not referenced.

           LDZ

                     LDZ is INTEGER
                     The leading dimension of the array Z.  LDZ >= 1.
                     If eigenvectors are desired, then LDZ >= max(1,N).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If COMPZ = 'N' or 'I', or N <= 1, LWORK must be at least 1.
                     If COMPZ = 'V' and N > 1, LWORK must be at least N*N.
                     Note that for COMPZ = 'V', then if N is less than or
                     equal to the minimum divide size, usually 25, then LWORK need
                     only be 1.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal sizes of the WORK, RWORK and
                     IWORK arrays, returns these values as the first entries of
                     the WORK, RWORK and IWORK arrays, and no error message
                     related to LWORK or LRWORK or LIWORK is issued by XERBLA.

           RWORK

                     RWORK is REAL array, dimension (MAX(1,LRWORK))
                     On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.

           LRWORK

                     LRWORK is INTEGER
                     The dimension of the array RWORK.
                     If COMPZ = 'N' or N <= 1, LRWORK must be at least 1.
                     If COMPZ = 'V' and N > 1, LRWORK must be at least
                                    1 + 3*N + 2*N*lg N + 4*N**2 ,
                                    where lg( N ) = smallest integer k such
                                    that 2**k >= N.
                     If COMPZ = 'I' and N > 1, LRWORK must be at least
                                    1 + 4*N + 2*N**2 .
                     Note that for COMPZ = 'I' or 'V', then if N is less than or
                     equal to the minimum divide size, usually 25, then LRWORK
                     need only be max(1,2*(N-1)).

                     If LRWORK = -1, then a workspace query is assumed; the
                     routine only calculates the optimal sizes of the WORK, RWORK
                     and IWORK arrays, returns these values as the first entries
                     of the WORK, RWORK and IWORK arrays, and no error message
                     related to LWORK or LRWORK or LIWORK is issued by XERBLA.

           IWORK

                     IWORK is INTEGER array, dimension (MAX(1,LIWORK))
                     On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.

           LIWORK

                     LIWORK is INTEGER
                     The dimension of the array IWORK.
                     If COMPZ = 'N' or N <= 1, LIWORK must be at least 1.
                     If COMPZ = 'V' or N > 1,  LIWORK must be at least
                                               6 + 6*N + 5*N*lg N.
                     If COMPZ = 'I' or N > 1,  LIWORK must be at least
                                               3 + 5*N .
                     Note that for COMPZ = 'I' or 'V', then if N is less than or
                     equal to the minimum divide size, usually 25, then LIWORK
                     need only be 1.

                     If LIWORK = -1, then a workspace query is assumed; the
                     routine only calculates the optimal sizes of the WORK, RWORK
                     and IWORK arrays, returns these values as the first entries
                     of the WORK, RWORK and IWORK arrays, and no error message
                     related to LWORK or LRWORK or LIWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  The algorithm failed to compute an eigenvalue while
                           working on the submatrix lying in rows and columns
                           INFO/(N+1) through mod(INFO,N+1).

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           Jeff Rutter, Computer Science Division, University of California at Berkeley, USA

   subroutine cstegr (character JOBZ, character RANGE, integer N, real, dimension( * ) D, real,
       dimension( * ) E, real VL, real VU, integer IL, integer IU, real ABSTOL, integer M, real,
       dimension( * ) W, complex, dimension( ldz, * ) Z, integer LDZ, integer, dimension( * )
       ISUPPZ, real, dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer
       LIWORK, integer INFO)
       CSTEGR

       Purpose:

            CSTEGR computes selected eigenvalues and, optionally, eigenvectors
            of a real symmetric tridiagonal matrix T. Any such unreduced matrix has
            a well defined set of pairwise different real eigenvalues, the corresponding
            real eigenvectors are pairwise orthogonal.

            The spectrum may be computed either completely or partially by specifying
            either an interval (VL,VU] or a range of indices IL:IU for the desired
            eigenvalues.

            CSTEGR is a compatibility wrapper around the improved CSTEMR routine.
            See SSTEMR for further details.

            One important change is that the ABSTOL parameter no longer provides any
            benefit and hence is no longer used.

            Note : CSTEGR and CSTEMR work only on machines which follow
            IEEE-754 floating-point standard in their handling of infinities and
            NaNs.  Normal execution may create these exceptiona values and hence
            may abort due to a floating point exception in environments which
            do not conform to the IEEE-754 standard.

       Parameters
           JOBZ

                     JOBZ is CHARACTER*1
                     = 'N':  Compute eigenvalues only;
                     = 'V':  Compute eigenvalues and eigenvectors.

           RANGE

                     RANGE is CHARACTER*1
                     = 'A': all eigenvalues will be found.
                     = 'V': all eigenvalues in the half-open interval (VL,VU]
                            will be found.
                     = 'I': the IL-th through IU-th eigenvalues will be found.

           N

                     N is INTEGER
                     The order of the matrix.  N >= 0.

           D

                     D is REAL array, dimension (N)
                     On entry, the N diagonal elements of the tridiagonal matrix
                     T. On exit, D is overwritten.

           E

                     E is REAL array, dimension (N)
                     On entry, the (N-1) subdiagonal elements of the tridiagonal
                     matrix T in elements 1 to N-1 of E. E(N) need not be set on
                     input, but is used internally as workspace.
                     On exit, E is overwritten.

           VL

                     VL is REAL

                     If RANGE='V', the lower bound of the interval to
                     be searched for eigenvalues. VL < VU.
                     Not referenced if RANGE = 'A' or 'I'.

           VU

                     VU is REAL

                     If RANGE='V', the upper bound of the interval to
                     be searched for eigenvalues. VL < VU.
                     Not referenced if RANGE = 'A' or 'I'.

           IL

                     IL is INTEGER

                     If RANGE='I', the index of the
                     smallest eigenvalue to be returned.
                     1 <= IL <= IU <= N, if N > 0.
                     Not referenced if RANGE = 'A' or 'V'.

           IU

                     IU is INTEGER

                     If RANGE='I', the index of the
                     largest eigenvalue to be returned.
                     1 <= IL <= IU <= N, if N > 0.
                     Not referenced if RANGE = 'A' or 'V'.

           ABSTOL

                     ABSTOL is REAL
                     Unused.  Was the absolute error tolerance for the
                     eigenvalues/eigenvectors in previous versions.

           M

                     M is INTEGER
                     The total number of eigenvalues found.  0 <= M <= N.
                     If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1.

           W

                     W is REAL array, dimension (N)
                     The first M elements contain the selected eigenvalues in
                     ascending order.

           Z

                     Z is COMPLEX array, dimension (LDZ, max(1,M) )
                     If JOBZ = 'V', and if INFO = 0, then the first M columns of Z
                     contain the orthonormal eigenvectors of the matrix T
                     corresponding to the selected eigenvalues, with the i-th
                     column of Z holding the eigenvector associated with W(i).
                     If JOBZ = 'N', then Z is not referenced.
                     Note: the user must ensure that at least max(1,M) columns are
                     supplied in the array Z; if RANGE = 'V', the exact value of M
                     is not known in advance and an upper bound must be used.
                     Supplying N columns is always safe.

           LDZ

                     LDZ is INTEGER
                     The leading dimension of the array Z.  LDZ >= 1, and if
                     JOBZ = 'V', then LDZ >= max(1,N).

           ISUPPZ

                     ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )
                     The support of the eigenvectors in Z, i.e., the indices
                     indicating the nonzero elements in Z. The i-th computed eigenvector
                     is nonzero only in elements ISUPPZ( 2*i-1 ) through
                     ISUPPZ( 2*i ). This is relevant in the case when the matrix
                     is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0.

           WORK

                     WORK is REAL array, dimension (LWORK)
                     On exit, if INFO = 0, WORK(1) returns the optimal
                     (and minimal) LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK >= max(1,18*N)
                     if JOBZ = 'V', and LWORK >= max(1,12*N) if JOBZ = 'N'.
                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           IWORK

                     IWORK is INTEGER array, dimension (LIWORK)
                     On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.

           LIWORK

                     LIWORK is INTEGER
                     The dimension of the array IWORK.  LIWORK >= max(1,10*N)
                     if the eigenvectors are desired, and LIWORK >= max(1,8*N)
                     if only the eigenvalues are to be computed.
                     If LIWORK = -1, then a workspace query is assumed; the
                     routine only calculates the optimal size of the IWORK array,
                     returns this value as the first entry of the IWORK array, and
                     no error message related to LIWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     On exit, INFO
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value
                     > 0:  if INFO = 1X, internal error in SLARRE,
                           if INFO = 2X, internal error in CLARRV.
                           Here, the digit X = ABS( IINFO ) < 10, where IINFO is
                           the nonzero error code returned by SLARRE or
                           CLARRV, respectively.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           Inderjit Dhillon, IBM Almaden, USA
            Osni Marques, LBNL/NERSC, USA
            Christof Voemel, LBNL/NERSC, USA

   subroutine cstein (integer N, real, dimension( * ) D, real, dimension( * ) E, integer M, real,
       dimension( * ) W, integer, dimension( * ) IBLOCK, integer, dimension( * ) ISPLIT, complex,
       dimension( ldz, * ) Z, integer LDZ, real, dimension( * ) WORK, integer, dimension( * )
       IWORK, integer, dimension( * ) IFAIL, integer INFO)
       CSTEIN

       Purpose:

            CSTEIN computes the eigenvectors of a real symmetric tridiagonal
            matrix T corresponding to specified eigenvalues, using inverse
            iteration.

            The maximum number of iterations allowed for each eigenvector is
            specified by an internal parameter MAXITS (currently set to 5).

            Although the eigenvectors are real, they are stored in a complex
            array, which may be passed to CUNMTR or CUPMTR for back
            transformation to the eigenvectors of a complex Hermitian matrix
            which was reduced to tridiagonal form.

       Parameters
           N

                     N is INTEGER
                     The order of the matrix.  N >= 0.

           D

                     D is REAL array, dimension (N)
                     The n diagonal elements of the tridiagonal matrix T.

           E

                     E is REAL array, dimension (N-1)
                     The (n-1) subdiagonal elements of the tridiagonal matrix
                     T, stored in elements 1 to N-1.

           M

                     M is INTEGER
                     The number of eigenvectors to be found.  0 <= M <= N.

           W

                     W is REAL array, dimension (N)
                     The first M elements of W contain the eigenvalues for
                     which eigenvectors are to be computed.  The eigenvalues
                     should be grouped by split-off block and ordered from
                     smallest to largest within the block.  ( The output array
                     W from SSTEBZ with ORDER = 'B' is expected here. )

           IBLOCK

                     IBLOCK is INTEGER array, dimension (N)
                     The submatrix indices associated with the corresponding
                     eigenvalues in W; IBLOCK(i)=1 if eigenvalue W(i) belongs to
                     the first submatrix from the top, =2 if W(i) belongs to
                     the second submatrix, etc.  ( The output array IBLOCK
                     from SSTEBZ is expected here. )

           ISPLIT

                     ISPLIT is INTEGER array, dimension (N)
                     The splitting points, at which T breaks up into submatrices.
                     The first submatrix consists of rows/columns 1 to
                     ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1
                     through ISPLIT( 2 ), etc.
                     ( The output array ISPLIT from SSTEBZ is expected here. )

           Z

                     Z is COMPLEX array, dimension (LDZ, M)
                     The computed eigenvectors.  The eigenvector associated
                     with the eigenvalue W(i) is stored in the i-th column of
                     Z.  Any vector which fails to converge is set to its current
                     iterate after MAXITS iterations.
                     The imaginary parts of the eigenvectors are set to zero.

           LDZ

                     LDZ is INTEGER
                     The leading dimension of the array Z.  LDZ >= max(1,N).

           WORK

                     WORK is REAL array, dimension (5*N)

           IWORK

                     IWORK is INTEGER array, dimension (N)

           IFAIL

                     IFAIL is INTEGER array, dimension (M)
                     On normal exit, all elements of IFAIL are zero.
                     If one or more eigenvectors fail to converge after
                     MAXITS iterations, then their indices are stored in
                     array IFAIL.

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value
                     > 0: if INFO = i, then i eigenvectors failed to converge
                          in MAXITS iterations.  Their indices are stored in
                          array IFAIL.

       Internal Parameters:

             MAXITS  INTEGER, default = 5
                     The maximum number of iterations performed.

             EXTRA   INTEGER, default = 2
                     The number of iterations performed after norm growth
                     criterion is satisfied, should be at least 1.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cstemr (character JOBZ, character RANGE, integer N, real, dimension( * ) D, real,
       dimension( * ) E, real VL, real VU, integer IL, integer IU, integer M, real, dimension( *
       ) W, complex, dimension( ldz, * ) Z, integer LDZ, integer NZC, integer, dimension( * )
       ISUPPZ, logical TRYRAC, real, dimension( * ) WORK, integer LWORK, integer, dimension( * )
       IWORK, integer LIWORK, integer INFO)
       CSTEMR

       Purpose:

            CSTEMR computes selected eigenvalues and, optionally, eigenvectors
            of a real symmetric tridiagonal matrix T. Any such unreduced matrix has
            a well defined set of pairwise different real eigenvalues, the corresponding
            real eigenvectors are pairwise orthogonal.

            The spectrum may be computed either completely or partially by specifying
            either an interval (VL,VU] or a range of indices IL:IU for the desired
            eigenvalues.

            Depending on the number of desired eigenvalues, these are computed either
            by bisection or the dqds algorithm. Numerically orthogonal eigenvectors are
            computed by the use of various suitable L D L^T factorizations near clusters
            of close eigenvalues (referred to as RRRs, Relatively Robust
            Representations). An informal sketch of the algorithm follows.

            For each unreduced block (submatrix) of T,
               (a) Compute T - sigma I  = L D L^T, so that L and D
                   define all the wanted eigenvalues to high relative accuracy.
                   This means that small relative changes in the entries of D and L
                   cause only small relative changes in the eigenvalues and
                   eigenvectors. The standard (unfactored) representation of the
                   tridiagonal matrix T does not have this property in general.
               (b) Compute the eigenvalues to suitable accuracy.
                   If the eigenvectors are desired, the algorithm attains full
                   accuracy of the computed eigenvalues only right before
                   the corresponding vectors have to be computed, see steps c) and d).
               (c) For each cluster of close eigenvalues, select a new
                   shift close to the cluster, find a new factorization, and refine
                   the shifted eigenvalues to suitable accuracy.
               (d) For each eigenvalue with a large enough relative separation compute
                   the corresponding eigenvector by forming a rank revealing twisted
                   factorization. Go back to (c) for any clusters that remain.

            For more details, see:
            - Inderjit S. Dhillon and Beresford N. Parlett: "Multiple representations
              to compute orthogonal eigenvectors of symmetric tridiagonal matrices,"
              Linear Algebra and its Applications, 387(1), pp. 1-28, August 2004.
            - Inderjit Dhillon and Beresford Parlett: "Orthogonal Eigenvectors and
              Relative Gaps," SIAM Journal on Matrix Analysis and Applications, Vol. 25,
              2004.  Also LAPACK Working Note 154.
            - Inderjit Dhillon: "A new O(n^2) algorithm for the symmetric
              tridiagonal eigenvalue/eigenvector problem",
              Computer Science Division Technical Report No. UCB/CSD-97-971,
              UC Berkeley, May 1997.

            Further Details
            1.CSTEMR works only on machines which follow IEEE-754
            floating-point standard in their handling of infinities and NaNs.
            This permits the use of efficient inner loops avoiding a check for
            zero divisors.

            2. LAPACK routines can be used to reduce a complex Hermitean matrix to
            real symmetric tridiagonal form.

            (Any complex Hermitean tridiagonal matrix has real values on its diagonal
            and potentially complex numbers on its off-diagonals. By applying a
            similarity transform with an appropriate diagonal matrix
            diag(1,e^{i hy_1}, ... , e^{i hy_{n-1}}), the complex Hermitean
            matrix can be transformed into a real symmetric matrix and complex
            arithmetic can be entirely avoided.)

            While the eigenvectors of the real symmetric tridiagonal matrix are real,
            the eigenvectors of original complex Hermitean matrix have complex entries
            in general.
            Since LAPACK drivers overwrite the matrix data with the eigenvectors,
            CSTEMR accepts complex workspace to facilitate interoperability
            with CUNMTR or CUPMTR.

       Parameters
           JOBZ

                     JOBZ is CHARACTER*1
                     = 'N':  Compute eigenvalues only;
                     = 'V':  Compute eigenvalues and eigenvectors.

           RANGE

                     RANGE is CHARACTER*1
                     = 'A': all eigenvalues will be found.
                     = 'V': all eigenvalues in the half-open interval (VL,VU]
                            will be found.
                     = 'I': the IL-th through IU-th eigenvalues will be found.

           N

                     N is INTEGER
                     The order of the matrix.  N >= 0.

           D

                     D is REAL array, dimension (N)
                     On entry, the N diagonal elements of the tridiagonal matrix
                     T. On exit, D is overwritten.

           E

                     E is REAL array, dimension (N)
                     On entry, the (N-1) subdiagonal elements of the tridiagonal
                     matrix T in elements 1 to N-1 of E. E(N) need not be set on
                     input, but is used internally as workspace.
                     On exit, E is overwritten.

           VL

                     VL is REAL

                     If RANGE='V', the lower bound of the interval to
                     be searched for eigenvalues. VL < VU.
                     Not referenced if RANGE = 'A' or 'I'.

           VU

                     VU is REAL

                     If RANGE='V', the upper bound of the interval to
                     be searched for eigenvalues. VL < VU.
                     Not referenced if RANGE = 'A' or 'I'.

           IL

                     IL is INTEGER

                     If RANGE='I', the index of the
                     smallest eigenvalue to be returned.
                     1 <= IL <= IU <= N, if N > 0.
                     Not referenced if RANGE = 'A' or 'V'.

           IU

                     IU is INTEGER

                     If RANGE='I', the index of the
                     largest eigenvalue to be returned.
                     1 <= IL <= IU <= N, if N > 0.
                     Not referenced if RANGE = 'A' or 'V'.

           M

                     M is INTEGER
                     The total number of eigenvalues found.  0 <= M <= N.
                     If RANGE = 'A', M = N, and if RANGE = 'I', M = IU-IL+1.

           W

                     W is REAL array, dimension (N)
                     The first M elements contain the selected eigenvalues in
                     ascending order.

           Z

                     Z is COMPLEX array, dimension (LDZ, max(1,M) )
                     If JOBZ = 'V', and if INFO = 0, then the first M columns of Z
                     contain the orthonormal eigenvectors of the matrix T
                     corresponding to the selected eigenvalues, with the i-th
                     column of Z holding the eigenvector associated with W(i).
                     If JOBZ = 'N', then Z is not referenced.
                     Note: the user must ensure that at least max(1,M) columns are
                     supplied in the array Z; if RANGE = 'V', the exact value of M
                     is not known in advance and can be computed with a workspace
                     query by setting NZC = -1, see below.

           LDZ

                     LDZ is INTEGER
                     The leading dimension of the array Z.  LDZ >= 1, and if
                     JOBZ = 'V', then LDZ >= max(1,N).

           NZC

                     NZC is INTEGER
                     The number of eigenvectors to be held in the array Z.
                     If RANGE = 'A', then NZC >= max(1,N).
                     If RANGE = 'V', then NZC >= the number of eigenvalues in (VL,VU].
                     If RANGE = 'I', then NZC >= IU-IL+1.
                     If NZC = -1, then a workspace query is assumed; the
                     routine calculates the number of columns of the array Z that
                     are needed to hold the eigenvectors.
                     This value is returned as the first entry of the Z array, and
                     no error message related to NZC is issued by XERBLA.

           ISUPPZ

                     ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )
                     The support of the eigenvectors in Z, i.e., the indices
                     indicating the nonzero elements in Z. The i-th computed eigenvector
                     is nonzero only in elements ISUPPZ( 2*i-1 ) through
                     ISUPPZ( 2*i ). This is relevant in the case when the matrix
                     is split. ISUPPZ is only accessed when JOBZ is 'V' and N > 0.

           TRYRAC

                     TRYRAC is LOGICAL
                     If TRYRAC = .TRUE., indicates that the code should check whether
                     the tridiagonal matrix defines its eigenvalues to high relative
                     accuracy.  If so, the code uses relative-accuracy preserving
                     algorithms that might be (a bit) slower depending on the matrix.
                     If the matrix does not define its eigenvalues to high relative
                     accuracy, the code can uses possibly faster algorithms.
                     If TRYRAC = .FALSE., the code is not required to guarantee
                     relatively accurate eigenvalues and can use the fastest possible
                     techniques.
                     On exit, a .TRUE. TRYRAC will be set to .FALSE. if the matrix
                     does not define its eigenvalues to high relative accuracy.

           WORK

                     WORK is REAL array, dimension (LWORK)
                     On exit, if INFO = 0, WORK(1) returns the optimal
                     (and minimal) LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK >= max(1,18*N)
                     if JOBZ = 'V', and LWORK >= max(1,12*N) if JOBZ = 'N'.
                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           IWORK

                     IWORK is INTEGER array, dimension (LIWORK)
                     On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.

           LIWORK

                     LIWORK is INTEGER
                     The dimension of the array IWORK.  LIWORK >= max(1,10*N)
                     if the eigenvectors are desired, and LIWORK >= max(1,8*N)
                     if only the eigenvalues are to be computed.
                     If LIWORK = -1, then a workspace query is assumed; the
                     routine only calculates the optimal size of the IWORK array,
                     returns this value as the first entry of the IWORK array, and
                     no error message related to LIWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     On exit, INFO
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value
                     > 0:  if INFO = 1X, internal error in SLARRE,
                           if INFO = 2X, internal error in CLARRV.
                           Here, the digit X = ABS( IINFO ) < 10, where IINFO is
                           the nonzero error code returned by SLARRE or
                           CLARRV, respectively.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           Beresford Parlett, University of California, Berkeley, USA
            Jim Demmel, University of California, Berkeley, USA
            Inderjit Dhillon, University of Texas, Austin, USA
            Osni Marques, LBNL/NERSC, USA
            Christof Voemel, University of California, Berkeley, USA

   subroutine csteqr (character COMPZ, integer N, real, dimension( * ) D, real, dimension( * ) E,
       complex, dimension( ldz, * ) Z, integer LDZ, real, dimension( * ) WORK, integer INFO)
       CSTEQR

       Purpose:

            CSTEQR computes all eigenvalues and, optionally, eigenvectors of a
            symmetric tridiagonal matrix using the implicit QL or QR method.
            The eigenvectors of a full or band complex Hermitian matrix can also
            be found if CHETRD or CHPTRD or CHBTRD has been used to reduce this
            matrix to tridiagonal form.

       Parameters
           COMPZ

                     COMPZ is CHARACTER*1
                     = 'N':  Compute eigenvalues only.
                     = 'V':  Compute eigenvalues and eigenvectors of the original
                             Hermitian matrix.  On entry, Z must contain the
                             unitary matrix used to reduce the original matrix
                             to tridiagonal form.
                     = 'I':  Compute eigenvalues and eigenvectors of the
                             tridiagonal matrix.  Z is initialized to the identity
                             matrix.

           N

                     N is INTEGER
                     The order of the matrix.  N >= 0.

           D

                     D is REAL array, dimension (N)
                     On entry, the diagonal elements of the tridiagonal matrix.
                     On exit, if INFO = 0, the eigenvalues in ascending order.

           E

                     E is REAL array, dimension (N-1)
                     On entry, the (n-1) subdiagonal elements of the tridiagonal
                     matrix.
                     On exit, E has been destroyed.

           Z

                     Z is COMPLEX array, dimension (LDZ, N)
                     On entry, if  COMPZ = 'V', then Z contains the unitary
                     matrix used in the reduction to tridiagonal form.
                     On exit, if INFO = 0, then if COMPZ = 'V', Z contains the
                     orthonormal eigenvectors of the original Hermitian matrix,
                     and if COMPZ = 'I', Z contains the orthonormal eigenvectors
                     of the symmetric tridiagonal matrix.
                     If COMPZ = 'N', then Z is not referenced.

           LDZ

                     LDZ is INTEGER
                     The leading dimension of the array Z.  LDZ >= 1, and if
                     eigenvectors are desired, then  LDZ >= max(1,N).

           WORK

                     WORK is REAL array, dimension (max(1,2*N-2))
                     If COMPZ = 'N', then WORK is not referenced.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value
                     > 0:  the algorithm has failed to find all the eigenvalues in
                           a total of 30*N iterations; if INFO = i, then i
                           elements of E have not converged to zero; on exit, D
                           and E contain the elements of a symmetric tridiagonal
                           matrix which is unitarily similar to the original
                           matrix.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctbcon (character NORM, character UPLO, character DIAG, integer N, integer KD,
       complex, dimension( ldab, * ) AB, integer LDAB, real RCOND, complex, dimension( * ) WORK,
       real, dimension( * ) RWORK, integer INFO)
       CTBCON

       Purpose:

            CTBCON estimates the reciprocal of the condition number of a
            triangular band matrix A, in either the 1-norm or the infinity-norm.

            The norm of A is computed and an estimate is obtained for
            norm(inv(A)), then the reciprocal of the condition number is
            computed as
               RCOND = 1 / ( norm(A) * norm(inv(A)) ).

       Parameters
           NORM

                     NORM is CHARACTER*1
                     Specifies whether the 1-norm condition number or the
                     infinity-norm condition number is required:
                     = '1' or 'O':  1-norm;
                     = 'I':         Infinity-norm.

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           DIAG

                     DIAG is CHARACTER*1
                     = 'N':  A is non-unit triangular;
                     = 'U':  A is unit triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           KD

                     KD is INTEGER
                     The number of superdiagonals or subdiagonals of the
                     triangular band matrix A.  KD >= 0.

           AB

                     AB is COMPLEX array, dimension (LDAB,N)
                     The upper or lower triangular band matrix A, stored in the
                     first kd+1 rows of the array. The j-th column of A is stored
                     in the j-th column of the array AB as follows:
                     if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
                     if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).
                     If DIAG = 'U', the diagonal elements of A are not referenced
                     and are assumed to be 1.

           LDAB

                     LDAB is INTEGER
                     The leading dimension of the array AB.  LDAB >= KD+1.

           RCOND

                     RCOND is REAL
                     The reciprocal of the condition number of the matrix A,
                     computed as RCOND = 1/(norm(A) * norm(inv(A))).

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctbrfs (character UPLO, character TRANS, character DIAG, integer N, integer KD,
       integer NRHS, complex, dimension( ldab, * ) AB, integer LDAB, complex, dimension( ldb, * )
       B, integer LDB, complex, dimension( ldx, * ) X, integer LDX, real, dimension( * ) FERR,
       real, dimension( * ) BERR, complex, dimension( * ) WORK, real, dimension( * ) RWORK,
       integer INFO)
       CTBRFS

       Purpose:

            CTBRFS provides error bounds and backward error estimates for the
            solution to a system of linear equations with a triangular band
            coefficient matrix.

            The solution matrix X must be computed by CTBTRS or some other
            means before entering this routine.  CTBRFS does not do iterative
            refinement because doing so cannot improve the backward error.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations:
                     = 'N':  A * X = B     (No transpose)
                     = 'T':  A**T * X = B  (Transpose)
                     = 'C':  A**H * X = B  (Conjugate transpose)

           DIAG

                     DIAG is CHARACTER*1
                     = 'N':  A is non-unit triangular;
                     = 'U':  A is unit triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           KD

                     KD is INTEGER
                     The number of superdiagonals or subdiagonals of the
                     triangular band matrix A.  KD >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrices B and X.  NRHS >= 0.

           AB

                     AB is COMPLEX array, dimension (LDAB,N)
                     The upper or lower triangular band matrix A, stored in the
                     first kd+1 rows of the array. The j-th column of A is stored
                     in the j-th column of the array AB as follows:
                     if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
                     if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).
                     If DIAG = 'U', the diagonal elements of A are not referenced
                     and are assumed to be 1.

           LDAB

                     LDAB is INTEGER
                     The leading dimension of the array AB.  LDAB >= KD+1.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     The right hand side matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           X

                     X is COMPLEX array, dimension (LDX,NRHS)
                     The solution matrix X.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  LDX >= max(1,N).

           FERR

                     FERR is REAL array, dimension (NRHS)
                     The estimated forward error bound for each solution vector
                     X(j) (the j-th column of the solution matrix X).
                     If XTRUE is the true solution corresponding to X(j), FERR(j)
                     is an estimated upper bound for the magnitude of the largest
                     element in (X(j) - XTRUE) divided by the magnitude of the
                     largest element in X(j).  The estimate is as reliable as
                     the estimate for RCOND, and is almost always a slight
                     overestimate of the true error.

           BERR

                     BERR is REAL array, dimension (NRHS)
                     The componentwise relative backward error of each solution
                     vector X(j) (i.e., the smallest relative change in
                     any element of A or B that makes X(j) an exact solution).

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctbtrs (character UPLO, character TRANS, character DIAG, integer N, integer KD,
       integer NRHS, complex, dimension( ldab, * ) AB, integer LDAB, complex, dimension( ldb, * )
       B, integer LDB, integer INFO)
       CTBTRS

       Purpose:

            CTBTRS solves a triangular system of the form

               A * X = B,  A**T * X = B,  or  A**H * X = B,

            where A is a triangular band matrix of order N, and B is an
            N-by-NRHS matrix.  A check is made to verify that A is nonsingular.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations:
                     = 'N':  A * X = B     (No transpose)
                     = 'T':  A**T * X = B  (Transpose)
                     = 'C':  A**H * X = B  (Conjugate transpose)

           DIAG

                     DIAG is CHARACTER*1
                     = 'N':  A is non-unit triangular;
                     = 'U':  A is unit triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           KD

                     KD is INTEGER
                     The number of superdiagonals or subdiagonals of the
                     triangular band matrix A.  KD >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrix B.  NRHS >= 0.

           AB

                     AB is COMPLEX array, dimension (LDAB,N)
                     The upper or lower triangular band matrix A, stored in the
                     first kd+1 rows of AB.  The j-th column of A is stored
                     in the j-th column of the array AB as follows:
                     if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
                     if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).
                     If DIAG = 'U', the diagonal elements of A are not referenced
                     and are assumed to be 1.

           LDAB

                     LDAB is INTEGER
                     The leading dimension of the array AB.  LDAB >= KD+1.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     On entry, the right hand side matrix B.
                     On exit, if INFO = 0, the solution matrix X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value
                     > 0:  if INFO = i, the i-th diagonal element of A is zero,
                           indicating that the matrix is singular and the
                           solutions X have not been computed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctfsm (character TRANSR, character SIDE, character UPLO, character TRANS, character
       DIAG, integer M, integer N, complex ALPHA, complex, dimension( 0: * ) A, complex,
       dimension( 0: ldb-1, 0: * ) B, integer LDB)
       CTFSM solves a matrix equation (one operand is a triangular matrix in RFP format).

       Purpose:

            Level 3 BLAS like routine for A in RFP Format.

            CTFSM solves the matrix equation

               op( A )*X = alpha*B  or  X*op( A ) = alpha*B

            where alpha is a scalar, X and B are m by n matrices, A is a unit, or
            non-unit,  upper or lower triangular matrix  and  op( A )  is one  of

               op( A ) = A   or   op( A ) = A**H.

            A is in Rectangular Full Packed (RFP) Format.

            The matrix X is overwritten on B.

       Parameters
           TRANSR

                     TRANSR is CHARACTER*1
                     = 'N':  The Normal Form of RFP A is stored;
                     = 'C':  The Conjugate-transpose Form of RFP A is stored.

           SIDE

                     SIDE is CHARACTER*1
                      On entry, SIDE specifies whether op( A ) appears on the left
                      or right of X as follows:

                         SIDE = 'L' or 'l'   op( A )*X = alpha*B.

                         SIDE = 'R' or 'r'   X*op( A ) = alpha*B.

                      Unchanged on exit.

           UPLO

                     UPLO is CHARACTER*1
                      On entry, UPLO specifies whether the RFP matrix A came from
                      an upper or lower triangular matrix as follows:
                      UPLO = 'U' or 'u' RFP A came from an upper triangular matrix
                      UPLO = 'L' or 'l' RFP A came from a  lower triangular matrix

                      Unchanged on exit.

           TRANS

                     TRANS is CHARACTER*1
                      On entry, TRANS  specifies the form of op( A ) to be used
                      in the matrix multiplication as follows:

                         TRANS  = 'N' or 'n'   op( A ) = A.

                         TRANS  = 'C' or 'c'   op( A ) = conjg( A' ).

                      Unchanged on exit.

           DIAG

                     DIAG is CHARACTER*1
                      On entry, DIAG specifies whether or not RFP A is unit
                      triangular as follows:

                         DIAG = 'U' or 'u'   A is assumed to be unit triangular.

                         DIAG = 'N' or 'n'   A is not assumed to be unit
                                             triangular.

                      Unchanged on exit.

           M

                     M is INTEGER
                      On entry, M specifies the number of rows of B. M must be at
                      least zero.
                      Unchanged on exit.

           N

                     N is INTEGER
                      On entry, N specifies the number of columns of B.  N must be
                      at least zero.
                      Unchanged on exit.

           ALPHA

                     ALPHA is COMPLEX
                      On entry,  ALPHA specifies the scalar  alpha. When  alpha is
                      zero then  A is not referenced and  B need not be set before
                      entry.
                      Unchanged on exit.

           A

                     A is COMPLEX array, dimension (N*(N+1)/2)
                      NT = N*(N+1)/2. On entry, the matrix A in RFP Format.
                      RFP Format is described by TRANSR, UPLO and N as follows:
                      If TRANSR='N' then RFP A is (0:N,0:K-1) when N is even;
                      K=N/2. RFP A is (0:N-1,0:K) when N is odd; K=N/2. If
                      TRANSR = 'C' then RFP is the Conjugate-transpose of RFP A as
                      defined when TRANSR = 'N'. The contents of RFP A are defined
                      by UPLO as follows: If UPLO = 'U' the RFP A contains the NT
                      elements of upper packed A either in normal or
                      conjugate-transpose Format. If UPLO = 'L' the RFP A contains
                      the NT elements of lower packed A either in normal or
                      conjugate-transpose Format. The LDA of RFP A is (N+1)/2 when
                      TRANSR = 'C'. When TRANSR is 'N' the LDA is N+1 when N is
                      even and is N when is odd.
                      See the Note below for more details. Unchanged on exit.

           B

                     B is COMPLEX array, dimension (LDB,N)
                      Before entry,  the leading  m by n part of the array  B must
                      contain  the  right-hand  side  matrix  B,  and  on exit  is
                      overwritten by the solution matrix  X.

           LDB

                     LDB is INTEGER
                      On entry, LDB specifies the first dimension of B as declared
                      in  the  calling  (sub)  program.   LDB  must  be  at  least
                      max( 1, m ).
                      Unchanged on exit.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             We first consider Standard Packed Format when N is even.
             We give an example where N = 6.

                 AP is Upper             AP is Lower

              00 01 02 03 04 05       00
                 11 12 13 14 15       10 11
                    22 23 24 25       20 21 22
                       33 34 35       30 31 32 33
                          44 45       40 41 42 43 44
                             55       50 51 52 53 54 55

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last
             three columns of AP upper. The lower triangle A(4:6,0:2) consists of
             conjugate-transpose of the first three columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:2,0:2) consists of
             conjugate-transpose of the last three columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N even and TRANSR = 'N'.

                    RFP A                   RFP A

                                           -- -- --
                   03 04 05                33 43 53
                                              -- --
                   13 14 15                00 44 54
                                                 --
                   23 24 25                10 11 55

                   33 34 35                20 21 22
                   --
                   00 44 45                30 31 32
                   -- --
                   01 11 55                40 41 42
                   -- -- --
                   02 12 22                50 51 52

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- -- --                -- -- -- -- -- --
                03 13 23 33 00 01 02    33 00 10 20 30 40 50
                -- -- -- -- --                -- -- -- -- --
                04 14 24 34 44 11 12    43 44 11 21 31 41 51
                -- -- -- -- -- --                -- -- -- --
                05 15 25 35 45 55 22    53 54 55 22 32 42 52

             We next  consider Standard Packed Format when N is odd.
             We give an example where N = 5.

                AP is Upper                 AP is Lower

              00 01 02 03 04              00
                 11 12 13 14              10 11
                    22 23 24              20 21 22
                       33 34              30 31 32 33
                          44              40 41 42 43 44

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last
             three columns of AP upper. The lower triangle A(3:4,0:1) consists of
             conjugate-transpose of the first two   columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:1,1:2) consists of
             conjugate-transpose of the last two   columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N odd  and TRANSR = 'N'.

                    RFP A                   RFP A

                                              -- --
                   02 03 04                00 33 43
                                                 --
                   12 13 14                10 11 44

                   22 23 24                20 21 22
                   --
                   00 33 34                30 31 32
                   -- --
                   01 11 44                40 41 42

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- --                   -- -- -- -- -- --
                02 12 22 00 01             00 10 20 30 40 50
                -- -- -- --                   -- -- -- -- --
                03 13 23 33 11             33 11 21 31 41 51
                -- -- -- -- --                   -- -- -- --
                04 14 24 34 44             43 44 22 32 42 52

   subroutine ctftri (character TRANSR, character UPLO, character DIAG, integer N, complex,
       dimension( 0: * ) A, integer INFO)
       CTFTRI

       Purpose:

            CTFTRI computes the inverse of a triangular matrix A stored in RFP
            format.

            This is a Level 3 BLAS version of the algorithm.

       Parameters
           TRANSR

                     TRANSR is CHARACTER*1
                     = 'N':  The Normal TRANSR of RFP A is stored;
                     = 'C':  The Conjugate-transpose TRANSR of RFP A is stored.

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           DIAG

                     DIAG is CHARACTER*1
                     = 'N':  A is non-unit triangular;
                     = 'U':  A is unit triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           A

                     A is COMPLEX array, dimension ( N*(N+1)/2 );
                     On entry, the triangular matrix A in RFP format. RFP format
                     is described by TRANSR, UPLO, and N as follows: If TRANSR =
                     'N' then RFP A is (0:N,0:k-1) when N is even; k=N/2. RFP A is
                     (0:N-1,0:k) when N is odd; k=N/2. IF TRANSR = 'C' then RFP is
                     the Conjugate-transpose of RFP A as defined when
                     TRANSR = 'N'. The contents of RFP A are defined by UPLO as
                     follows: If UPLO = 'U' the RFP A contains the nt elements of
                     upper packed A; If UPLO = 'L' the RFP A contains the nt
                     elements of lower packed A. The LDA of RFP A is (N+1)/2 when
                     TRANSR = 'C'. When TRANSR is 'N' the LDA is N+1 when N is
                     even and N is odd. See the Note below for more details.

                     On exit, the (triangular) inverse of the original matrix, in
                     the same storage format.

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value
                     > 0: if INFO = i, A(i,i) is exactly zero.  The triangular
                          matrix is singular and its inverse can not be computed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             We first consider Standard Packed Format when N is even.
             We give an example where N = 6.

                 AP is Upper             AP is Lower

              00 01 02 03 04 05       00
                 11 12 13 14 15       10 11
                    22 23 24 25       20 21 22
                       33 34 35       30 31 32 33
                          44 45       40 41 42 43 44
                             55       50 51 52 53 54 55

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last
             three columns of AP upper. The lower triangle A(4:6,0:2) consists of
             conjugate-transpose of the first three columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:2,0:2) consists of
             conjugate-transpose of the last three columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N even and TRANSR = 'N'.

                    RFP A                   RFP A

                                           -- -- --
                   03 04 05                33 43 53
                                              -- --
                   13 14 15                00 44 54
                                                 --
                   23 24 25                10 11 55

                   33 34 35                20 21 22
                   --
                   00 44 45                30 31 32
                   -- --
                   01 11 55                40 41 42
                   -- -- --
                   02 12 22                50 51 52

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- -- --                -- -- -- -- -- --
                03 13 23 33 00 01 02    33 00 10 20 30 40 50
                -- -- -- -- --                -- -- -- -- --
                04 14 24 34 44 11 12    43 44 11 21 31 41 51
                -- -- -- -- -- --                -- -- -- --
                05 15 25 35 45 55 22    53 54 55 22 32 42 52

             We next  consider Standard Packed Format when N is odd.
             We give an example where N = 5.

                AP is Upper                 AP is Lower

              00 01 02 03 04              00
                 11 12 13 14              10 11
                    22 23 24              20 21 22
                       33 34              30 31 32 33
                          44              40 41 42 43 44

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last
             three columns of AP upper. The lower triangle A(3:4,0:1) consists of
             conjugate-transpose of the first two   columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:1,1:2) consists of
             conjugate-transpose of the last two   columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N odd  and TRANSR = 'N'.

                    RFP A                   RFP A

                                              -- --
                   02 03 04                00 33 43
                                                 --
                   12 13 14                10 11 44

                   22 23 24                20 21 22
                   --
                   00 33 34                30 31 32
                   -- --
                   01 11 44                40 41 42

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- --                   -- -- -- -- -- --
                02 12 22 00 01             00 10 20 30 40 50
                -- -- -- --                   -- -- -- -- --
                03 13 23 33 11             33 11 21 31 41 51
                -- -- -- -- --                   -- -- -- --
                04 14 24 34 44             43 44 22 32 42 52

   subroutine ctfttp (character TRANSR, character UPLO, integer N, complex, dimension( 0: * )
       ARF, complex, dimension( 0: * ) AP, integer INFO)
       CTFTTP copies a triangular matrix from the rectangular full packed format (TF) to the
       standard packed format (TP).

       Purpose:

            CTFTTP copies a triangular matrix A from rectangular full packed
            format (TF) to standard packed format (TP).

       Parameters
           TRANSR

                     TRANSR is CHARACTER*1
                     = 'N':  ARF is in Normal format;
                     = 'C':  ARF is in Conjugate-transpose format;

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           N

                     N is INTEGER
                     The order of the matrix A. N >= 0.

           ARF

                     ARF is COMPLEX array, dimension ( N*(N+1)/2 ),
                     On entry, the upper or lower triangular matrix A stored in
                     RFP format. For a further discussion see Notes below.

           AP

                     AP is COMPLEX array, dimension ( N*(N+1)/2 ),
                     On exit, the upper or lower triangular matrix A, packed
                     columnwise in a linear array. The j-th column of A is stored
                     in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             We first consider Standard Packed Format when N is even.
             We give an example where N = 6.

                 AP is Upper             AP is Lower

              00 01 02 03 04 05       00
                 11 12 13 14 15       10 11
                    22 23 24 25       20 21 22
                       33 34 35       30 31 32 33
                          44 45       40 41 42 43 44
                             55       50 51 52 53 54 55

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last
             three columns of AP upper. The lower triangle A(4:6,0:2) consists of
             conjugate-transpose of the first three columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:2,0:2) consists of
             conjugate-transpose of the last three columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N even and TRANSR = 'N'.

                    RFP A                   RFP A

                                           -- -- --
                   03 04 05                33 43 53
                                              -- --
                   13 14 15                00 44 54
                                                 --
                   23 24 25                10 11 55

                   33 34 35                20 21 22
                   --
                   00 44 45                30 31 32
                   -- --
                   01 11 55                40 41 42
                   -- -- --
                   02 12 22                50 51 52

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- -- --                -- -- -- -- -- --
                03 13 23 33 00 01 02    33 00 10 20 30 40 50
                -- -- -- -- --                -- -- -- -- --
                04 14 24 34 44 11 12    43 44 11 21 31 41 51
                -- -- -- -- -- --                -- -- -- --
                05 15 25 35 45 55 22    53 54 55 22 32 42 52

             We next  consider Standard Packed Format when N is odd.
             We give an example where N = 5.

                AP is Upper                 AP is Lower

              00 01 02 03 04              00
                 11 12 13 14              10 11
                    22 23 24              20 21 22
                       33 34              30 31 32 33
                          44              40 41 42 43 44

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last
             three columns of AP upper. The lower triangle A(3:4,0:1) consists of
             conjugate-transpose of the first two   columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:1,1:2) consists of
             conjugate-transpose of the last two   columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N odd  and TRANSR = 'N'.

                    RFP A                   RFP A

                                              -- --
                   02 03 04                00 33 43
                                                 --
                   12 13 14                10 11 44

                   22 23 24                20 21 22
                   --
                   00 33 34                30 31 32
                   -- --
                   01 11 44                40 41 42

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- --                   -- -- -- -- -- --
                02 12 22 00 01             00 10 20 30 40 50
                -- -- -- --                   -- -- -- -- --
                03 13 23 33 11             33 11 21 31 41 51
                -- -- -- -- --                   -- -- -- --
                04 14 24 34 44             43 44 22 32 42 52

   subroutine ctfttr (character TRANSR, character UPLO, integer N, complex, dimension( 0: * )
       ARF, complex, dimension( 0: lda-1, 0: * ) A, integer LDA, integer INFO)
       CTFTTR copies a triangular matrix from the rectangular full packed format (TF) to the
       standard full format (TR).

       Purpose:

            CTFTTR copies a triangular matrix A from rectangular full packed
            format (TF) to standard full format (TR).

       Parameters
           TRANSR

                     TRANSR is CHARACTER*1
                     = 'N':  ARF is in Normal format;
                     = 'C':  ARF is in Conjugate-transpose format;

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           ARF

                     ARF is COMPLEX array, dimension ( N*(N+1)/2 ),
                     On entry, the upper or lower triangular matrix A stored in
                     RFP format. For a further discussion see Notes below.

           A

                     A is COMPLEX array, dimension ( LDA, N )
                     On exit, the triangular matrix A.  If UPLO = 'U', the
                     leading N-by-N upper triangular part of the array A contains
                     the upper triangular matrix, and the strictly lower
                     triangular part of A is not referenced.  If UPLO = 'L', the
                     leading N-by-N lower triangular part of the array A contains
                     the lower triangular matrix, and the strictly upper
                     triangular part of A is not referenced.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             We first consider Standard Packed Format when N is even.
             We give an example where N = 6.

                 AP is Upper             AP is Lower

              00 01 02 03 04 05       00
                 11 12 13 14 15       10 11
                    22 23 24 25       20 21 22
                       33 34 35       30 31 32 33
                          44 45       40 41 42 43 44
                             55       50 51 52 53 54 55

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last
             three columns of AP upper. The lower triangle A(4:6,0:2) consists of
             conjugate-transpose of the first three columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:2,0:2) consists of
             conjugate-transpose of the last three columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N even and TRANSR = 'N'.

                    RFP A                   RFP A

                                           -- -- --
                   03 04 05                33 43 53
                                              -- --
                   13 14 15                00 44 54
                                                 --
                   23 24 25                10 11 55

                   33 34 35                20 21 22
                   --
                   00 44 45                30 31 32
                   -- --
                   01 11 55                40 41 42
                   -- -- --
                   02 12 22                50 51 52

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- -- --                -- -- -- -- -- --
                03 13 23 33 00 01 02    33 00 10 20 30 40 50
                -- -- -- -- --                -- -- -- -- --
                04 14 24 34 44 11 12    43 44 11 21 31 41 51
                -- -- -- -- -- --                -- -- -- --
                05 15 25 35 45 55 22    53 54 55 22 32 42 52

             We next  consider Standard Packed Format when N is odd.
             We give an example where N = 5.

                AP is Upper                 AP is Lower

              00 01 02 03 04              00
                 11 12 13 14              10 11
                    22 23 24              20 21 22
                       33 34              30 31 32 33
                          44              40 41 42 43 44

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last
             three columns of AP upper. The lower triangle A(3:4,0:1) consists of
             conjugate-transpose of the first two   columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:1,1:2) consists of
             conjugate-transpose of the last two   columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N odd  and TRANSR = 'N'.

                    RFP A                   RFP A

                                              -- --
                   02 03 04                00 33 43
                                                 --
                   12 13 14                10 11 44

                   22 23 24                20 21 22
                   --
                   00 33 34                30 31 32
                   -- --
                   01 11 44                40 41 42

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- --                   -- -- -- -- -- --
                02 12 22 00 01             00 10 20 30 40 50
                -- -- -- --                   -- -- -- -- --
                03 13 23 33 11             33 11 21 31 41 51
                -- -- -- -- --                   -- -- -- --
                04 14 24 34 44             43 44 22 32 42 52

   subroutine ctgsen (integer IJOB, logical WANTQ, logical WANTZ, logical, dimension( * ) SELECT,
       integer N, complex, dimension( lda, * ) A, integer LDA, complex, dimension( ldb, * ) B,
       integer LDB, complex, dimension( * ) ALPHA, complex, dimension( * ) BETA, complex,
       dimension( ldq, * ) Q, integer LDQ, complex, dimension( ldz, * ) Z, integer LDZ, integer
       M, real PL, real PR, real, dimension( * ) DIF, complex, dimension( * ) WORK, integer
       LWORK, integer, dimension( * ) IWORK, integer LIWORK, integer INFO)
       CTGSEN

       Purpose:

            CTGSEN reorders the generalized Schur decomposition of a complex
            matrix pair (A, B) (in terms of an unitary equivalence trans-
            formation Q**H * (A, B) * Z), so that a selected cluster of eigenvalues
            appears in the leading diagonal blocks of the pair (A,B). The leading
            columns of Q and Z form unitary bases of the corresponding left and
            right eigenspaces (deflating subspaces). (A, B) must be in
            generalized Schur canonical form, that is, A and B are both upper
            triangular.

            CTGSEN also computes the generalized eigenvalues

                     w(j)= ALPHA(j) / BETA(j)

            of the reordered matrix pair (A, B).

            Optionally, the routine computes estimates of reciprocal condition
            numbers for eigenvalues and eigenspaces. These are Difu[(A11,B11),
            (A22,B22)] and Difl[(A11,B11), (A22,B22)], i.e. the separation(s)
            between the matrix pairs (A11, B11) and (A22,B22) that correspond to
            the selected cluster and the eigenvalues outside the cluster, resp.,
            and norms of "projections" onto left and right eigenspaces w.r.t.
            the selected cluster in the (1,1)-block.

       Parameters
           IJOB

                     IJOB is INTEGER
                     Specifies whether condition numbers are required for the
                     cluster of eigenvalues (PL and PR) or the deflating subspaces
                     (Difu and Difl):
                      =0: Only reorder w.r.t. SELECT. No extras.
                      =1: Reciprocal of norms of "projections" onto left and right
                          eigenspaces w.r.t. the selected cluster (PL and PR).
                      =2: Upper bounds on Difu and Difl. F-norm-based estimate
                          (DIF(1:2)).
                      =3: Estimate of Difu and Difl. 1-norm-based estimate
                          (DIF(1:2)).
                          About 5 times as expensive as IJOB = 2.
                      =4: Compute PL, PR and DIF (i.e. 0, 1 and 2 above): Economic
                          version to get it all.
                      =5: Compute PL, PR and DIF (i.e. 0, 1 and 3 above)

           WANTQ

                     WANTQ is LOGICAL
                     .TRUE. : update the left transformation matrix Q;
                     .FALSE.: do not update Q.

           WANTZ

                     WANTZ is LOGICAL
                     .TRUE. : update the right transformation matrix Z;
                     .FALSE.: do not update Z.

           SELECT

                     SELECT is LOGICAL array, dimension (N)
                     SELECT specifies the eigenvalues in the selected cluster. To
                     select an eigenvalue w(j), SELECT(j) must be set to
                     .TRUE..

           N

                     N is INTEGER
                     The order of the matrices A and B. N >= 0.

           A

                     A is COMPLEX array, dimension(LDA,N)
                     On entry, the upper triangular matrix A, in generalized
                     Schur canonical form.
                     On exit, A is overwritten by the reordered matrix A.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= max(1,N).

           B

                     B is COMPLEX array, dimension(LDB,N)
                     On entry, the upper triangular matrix B, in generalized
                     Schur canonical form.
                     On exit, B is overwritten by the reordered matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B. LDB >= max(1,N).

           ALPHA

                     ALPHA is COMPLEX array, dimension (N)

           BETA

                     BETA is COMPLEX array, dimension (N)

                     The diagonal elements of A and B, respectively,
                     when the pair (A,B) has been reduced to generalized Schur
                     form.  ALPHA(i)/BETA(i) i=1,...,N are the generalized
                     eigenvalues.

           Q

                     Q is COMPLEX array, dimension (LDQ,N)
                     On entry, if WANTQ = .TRUE., Q is an N-by-N matrix.
                     On exit, Q has been postmultiplied by the left unitary
                     transformation matrix which reorder (A, B); The leading M
                     columns of Q form orthonormal bases for the specified pair of
                     left eigenspaces (deflating subspaces).
                     If WANTQ = .FALSE., Q is not referenced.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q. LDQ >= 1.
                     If WANTQ = .TRUE., LDQ >= N.

           Z

                     Z is COMPLEX array, dimension (LDZ,N)
                     On entry, if WANTZ = .TRUE., Z is an N-by-N matrix.
                     On exit, Z has been postmultiplied by the left unitary
                     transformation matrix which reorder (A, B); The leading M
                     columns of Z form orthonormal bases for the specified pair of
                     left eigenspaces (deflating subspaces).
                     If WANTZ = .FALSE., Z is not referenced.

           LDZ

                     LDZ is INTEGER
                     The leading dimension of the array Z. LDZ >= 1.
                     If WANTZ = .TRUE., LDZ >= N.

           M

                     M is INTEGER
                     The dimension of the specified pair of left and right
                     eigenspaces, (deflating subspaces) 0 <= M <= N.

           PL

                     PL is REAL

           PR

                     PR is REAL

                     If IJOB = 1, 4 or 5, PL, PR are lower bounds on the
                     reciprocal  of the norm of "projections" onto left and right
                     eigenspace with respect to the selected cluster.
                     0 < PL, PR <= 1.
                     If M = 0 or M = N, PL = PR  = 1.
                     If IJOB = 0, 2 or 3 PL, PR are not referenced.

           DIF

                     DIF is REAL array, dimension (2).
                     If IJOB >= 2, DIF(1:2) store the estimates of Difu and Difl.
                     If IJOB = 2 or 4, DIF(1:2) are F-norm-based upper bounds on
                     Difu and Difl. If IJOB = 3 or 5, DIF(1:2) are 1-norm-based
                     estimates of Difu and Difl, computed using reversed
                     communication with CLACN2.
                     If M = 0 or N, DIF(1:2) = F-norm([A, B]).
                     If IJOB = 0 or 1, DIF is not referenced.

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK >=  1
                     If IJOB = 1, 2 or 4, LWORK >=  2*M*(N-M)
                     If IJOB = 3 or 5, LWORK >=  4*M*(N-M)

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           IWORK

                     IWORK is INTEGER array, dimension (MAX(1,LIWORK))
                     On exit, if INFO = 0, IWORK(1) returns the optimal LIWORK.

           LIWORK

                     LIWORK is INTEGER
                     The dimension of the array IWORK. LIWORK >= 1.
                     If IJOB = 1, 2 or 4, LIWORK >=  N+2;
                     If IJOB = 3 or 5, LIWORK >= MAX(N+2, 2*M*(N-M));

                     If LIWORK = -1, then a workspace query is assumed; the
                     routine only calculates the optimal size of the IWORK array,
                     returns this value as the first entry of the IWORK array, and
                     no error message related to LIWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                       =0: Successful exit.
                       <0: If INFO = -i, the i-th argument had an illegal value.
                       =1: Reordering of (A, B) failed because the transformed
                           matrix pair (A, B) would be too far from generalized
                           Schur form; the problem is very ill-conditioned.
                           (A, B) may have been partially reordered.
                           If requested, 0 is returned in DIF(*), PL and PR.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             CTGSEN first collects the selected eigenvalues by computing unitary
             U and W that move them to the top left corner of (A, B). In other
             words, the selected eigenvalues are the eigenvalues of (A11, B11) in

                         U**H*(A, B)*W = (A11 A12) (B11 B12) n1
                                         ( 0  A22),( 0  B22) n2
                                           n1  n2    n1  n2

             where N = n1+n2 and U**H means the conjugate transpose of U. The first
             n1 columns of U and W span the specified pair of left and right
             eigenspaces (deflating subspaces) of (A, B).

             If (A, B) has been obtained from the generalized real Schur
             decomposition of a matrix pair (C, D) = Q*(A, B)*Z', then the
             reordered generalized Schur form of (C, D) is given by

                      (C, D) = (Q*U)*(U**H *(A, B)*W)*(Z*W)**H,

             and the first n1 columns of Q*U and Z*W span the corresponding
             deflating subspaces of (C, D) (Q and Z store Q*U and Z*W, resp.).

             Note that if the selected eigenvalue is sufficiently ill-conditioned,
             then its value may differ significantly from its value before
             reordering.

             The reciprocal condition numbers of the left and right eigenspaces
             spanned by the first n1 columns of U and W (or Q*U and Z*W) may
             be returned in DIF(1:2), corresponding to Difu and Difl, resp.

             The Difu and Difl are defined as:

                  Difu[(A11, B11), (A22, B22)] = sigma-min( Zu )
             and
                  Difl[(A11, B11), (A22, B22)] = Difu[(A22, B22), (A11, B11)],

             where sigma-min(Zu) is the smallest singular value of the
             (2*n1*n2)-by-(2*n1*n2) matrix

                  Zu = [ kron(In2, A11)  -kron(A22**H, In1) ]
                       [ kron(In2, B11)  -kron(B22**H, In1) ].

             Here, Inx is the identity matrix of size nx and A22**H is the
             conjuguate transpose of A22. kron(X, Y) is the Kronecker product between
             the matrices X and Y.

             When DIF(2) is small, small changes in (A, B) can cause large changes
             in the deflating subspace. An approximate (asymptotic) bound on the
             maximum angular error in the computed deflating subspaces is

                  EPS * norm((A, B)) / DIF(2),

             where EPS is the machine precision.

             The reciprocal norm of the projectors on the left and right
             eigenspaces associated with (A11, B11) may be returned in PL and PR.
             They are computed as follows. First we compute L and R so that
             P*(A, B)*Q is block diagonal, where

                  P = ( I -L ) n1           Q = ( I R ) n1
                      ( 0  I ) n2    and        ( 0 I ) n2
                        n1 n2                    n1 n2

             and (L, R) is the solution to the generalized Sylvester equation

                  A11*R - L*A22 = -A12
                  B11*R - L*B22 = -B12

             Then PL = (F-norm(L)**2+1)**(-1/2) and PR = (F-norm(R)**2+1)**(-1/2).
             An approximate (asymptotic) bound on the average absolute error of
             the selected eigenvalues is

                  EPS * norm((A, B)) / PL.

             There are also global error bounds which valid for perturbations up
             to a certain restriction:  A lower bound (x) on the smallest
             F-norm(E,F) for which an eigenvalue of (A11, B11) may move and
             coalesce with an eigenvalue of (A22, B22) under perturbation (E,F),
             (i.e. (A + E, B + F), is

              x = min(Difu,Difl)/((1/(PL*PL)+1/(PR*PR))**(1/2)+2*max(1/PL,1/PR)).

             An approximate bound on x can be computed from DIF(1:2), PL and PR.

             If y = ( F-norm(E,F) / x) <= 1, the angles between the perturbed
             (L', R') and unperturbed (L, R) left and right deflating subspaces
             associated with the selected cluster in the (1,1)-blocks can be
             bounded as

              max-angle(L, L') <= arctan( y * PL / (1 - y * (1 - PL * PL)**(1/2))
              max-angle(R, R') <= arctan( y * PR / (1 - y * (1 - PR * PR)**(1/2))

             See LAPACK User's Guide section 4.11 or the following references
             for more information.

             Note that if the default method for computing the Frobenius-norm-
             based estimate DIF is not wanted (see CLATDF), then the parameter
             IDIFJB (see below) should be changed from 3 to 4 (routine CLATDF
             (IJOB = 2 will be used)). See CTGSYL for more details.

       Contributors:
           Bo Kagstrom and Peter Poromaa, Department of Computing Science, Umea University, S-901
           87 Umea, Sweden.

       References:
           [1] B. Kagstrom; A Direct Method for Reordering Eigenvalues in the Generalized Real
           Schur Form of a Regular Matrix Pair (A, B), in M.S. Moonen et al (eds), Linear Algebra
           for Large Scale and Real-Time Applications, Kluwer Academic Publ. 1993, pp 195-218.
            [2] B. Kagstrom and P. Poromaa; Computing Eigenspaces with Specified Eigenvalues of a
           Regular Matrix Pair (A, B) and Condition Estimation: Theory, Algorithms and Software,
           Report UMINF - 94.04, Department of Computing Science, Umea University, S-901 87 Umea,
           Sweden, 1994. Also as LAPACK Working Note 87. To appear in Numerical Algorithms, 1996.
            [3] B. Kagstrom and P. Poromaa, LAPACK-Style Algorithms and Software for Solving the
           Generalized Sylvester Equation and Estimating the Separation between Regular Matrix
           Pairs, Report UMINF - 93.23, Department of Computing Science, Umea University, S-901
           87 Umea, Sweden, December 1993, Revised April 1994, Also as LAPACK working Note 75. To
           appear in ACM Trans. on Math. Software, Vol 22, No 1, 1996.

   subroutine ctgsja (character JOBU, character JOBV, character JOBQ, integer M, integer P,
       integer N, integer K, integer L, complex, dimension( lda, * ) A, integer LDA, complex,
       dimension( ldb, * ) B, integer LDB, real TOLA, real TOLB, real, dimension( * ) ALPHA,
       real, dimension( * ) BETA, complex, dimension( ldu, * ) U, integer LDU, complex,
       dimension( ldv, * ) V, integer LDV, complex, dimension( ldq, * ) Q, integer LDQ, complex,
       dimension( * ) WORK, integer NCYCLE, integer INFO)
       CTGSJA

       Purpose:

            CTGSJA computes the generalized singular value decomposition (GSVD)
            of two complex upper triangular (or trapezoidal) matrices A and B.

            On entry, it is assumed that matrices A and B have the following
            forms, which may be obtained by the preprocessing subroutine CGGSVP
            from a general M-by-N matrix A and P-by-N matrix B:

                         N-K-L  K    L
               A =    K ( 0    A12  A13 ) if M-K-L >= 0;
                      L ( 0     0   A23 )
                  M-K-L ( 0     0    0  )

                       N-K-L  K    L
               A =  K ( 0    A12  A13 ) if M-K-L < 0;
                  M-K ( 0     0   A23 )

                       N-K-L  K    L
               B =  L ( 0     0   B13 )
                  P-L ( 0     0    0  )

            where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular
            upper triangular; A23 is L-by-L upper triangular if M-K-L >= 0,
            otherwise A23 is (M-K)-by-L upper trapezoidal.

            On exit,

                   U**H *A*Q = D1*( 0 R ),    V**H *B*Q = D2*( 0 R ),

            where U, V and Q are unitary matrices.
            R is a nonsingular upper triangular matrix, and D1
            and D2 are ``diagonal'' matrices, which are of the following
            structures:

            If M-K-L >= 0,

                                K  L
                   D1 =     K ( I  0 )
                            L ( 0  C )
                        M-K-L ( 0  0 )

                               K  L
                   D2 = L   ( 0  S )
                        P-L ( 0  0 )

                           N-K-L  K    L
              ( 0 R ) = K (  0   R11  R12 ) K
                        L (  0    0   R22 ) L

            where

              C = diag( ALPHA(K+1), ... , ALPHA(K+L) ),
              S = diag( BETA(K+1),  ... , BETA(K+L) ),
              C**2 + S**2 = I.

              R is stored in A(1:K+L,N-K-L+1:N) on exit.

            If M-K-L < 0,

                           K M-K K+L-M
                D1 =   K ( I  0    0   )
                     M-K ( 0  C    0   )

                             K M-K K+L-M
                D2 =   M-K ( 0  S    0   )
                     K+L-M ( 0  0    I   )
                       P-L ( 0  0    0   )

                           N-K-L  K   M-K  K+L-M
            ( 0 R ) =    K ( 0    R11  R12  R13  )
                      M-K ( 0     0   R22  R23  )
                    K+L-M ( 0     0    0   R33  )

            where
            C = diag( ALPHA(K+1), ... , ALPHA(M) ),
            S = diag( BETA(K+1),  ... , BETA(M) ),
            C**2 + S**2 = I.

            R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored
                (  0  R22 R23 )
            in B(M-K+1:L,N+M-K-L+1:N) on exit.

            The computation of the unitary transformation matrices U, V or Q
            is optional.  These matrices may either be formed explicitly, or they
            may be postmultiplied into input matrices U1, V1, or Q1.

       Parameters
           JOBU

                     JOBU is CHARACTER*1
                     = 'U':  U must contain a unitary matrix U1 on entry, and
                             the product U1*U is returned;
                     = 'I':  U is initialized to the unit matrix, and the
                             unitary matrix U is returned;
                     = 'N':  U is not computed.

           JOBV

                     JOBV is CHARACTER*1
                     = 'V':  V must contain a unitary matrix V1 on entry, and
                             the product V1*V is returned;
                     = 'I':  V is initialized to the unit matrix, and the
                             unitary matrix V is returned;
                     = 'N':  V is not computed.

           JOBQ

                     JOBQ is CHARACTER*1
                     = 'Q':  Q must contain a unitary matrix Q1 on entry, and
                             the product Q1*Q is returned;
                     = 'I':  Q is initialized to the unit matrix, and the
                             unitary matrix Q is returned;
                     = 'N':  Q is not computed.

           M

                     M is INTEGER
                     The number of rows of the matrix A.  M >= 0.

           P

                     P is INTEGER
                     The number of rows of the matrix B.  P >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrices A and B.  N >= 0.

           K

                     K is INTEGER

           L

                     L is INTEGER

                     K and L specify the subblocks in the input matrices A and B:
                     A23 = A(K+1:MIN(K+L,M),N-L+1:N) and B13 = B(1:L,,N-L+1:N)
                     of A and B, whose GSVD is going to be computed by CTGSJA.
                     See Further Details.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the M-by-N matrix A.
                     On exit, A(N-K+1:N,1:MIN(K+L,M) ) contains the triangular
                     matrix R or part of R.  See Purpose for details.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= max(1,M).

           B

                     B is COMPLEX array, dimension (LDB,N)
                     On entry, the P-by-N matrix B.
                     On exit, if necessary, B(M-K+1:L,N+M-K-L+1:N) contains
                     a part of R.  See Purpose for details.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B. LDB >= max(1,P).

           TOLA

                     TOLA is REAL

           TOLB

                     TOLB is REAL

                     TOLA and TOLB are the convergence criteria for the Jacobi-
                     Kogbetliantz iteration procedure. Generally, they are the
                     same as used in the preprocessing step, say
                         TOLA = MAX(M,N)*norm(A)*MACHEPS,
                         TOLB = MAX(P,N)*norm(B)*MACHEPS.

           ALPHA

                     ALPHA is REAL array, dimension (N)

           BETA

                     BETA is REAL array, dimension (N)

                     On exit, ALPHA and BETA contain the generalized singular
                     value pairs of A and B;
                       ALPHA(1:K) = 1,
                       BETA(1:K)  = 0,
                     and if M-K-L >= 0,
                       ALPHA(K+1:K+L) = diag(C),
                       BETA(K+1:K+L)  = diag(S),
                     or if M-K-L < 0,
                       ALPHA(K+1:M)= C, ALPHA(M+1:K+L)= 0
                       BETA(K+1:M) = S, BETA(M+1:K+L) = 1.
                     Furthermore, if K+L < N,
                       ALPHA(K+L+1:N) = 0
                       BETA(K+L+1:N)  = 0.

           U

                     U is COMPLEX array, dimension (LDU,M)
                     On entry, if JOBU = 'U', U must contain a matrix U1 (usually
                     the unitary matrix returned by CGGSVP).
                     On exit,
                     if JOBU = 'I', U contains the unitary matrix U;
                     if JOBU = 'U', U contains the product U1*U.
                     If JOBU = 'N', U is not referenced.

           LDU

                     LDU is INTEGER
                     The leading dimension of the array U. LDU >= max(1,M) if
                     JOBU = 'U'; LDU >= 1 otherwise.

           V

                     V is COMPLEX array, dimension (LDV,P)
                     On entry, if JOBV = 'V', V must contain a matrix V1 (usually
                     the unitary matrix returned by CGGSVP).
                     On exit,
                     if JOBV = 'I', V contains the unitary matrix V;
                     if JOBV = 'V', V contains the product V1*V.
                     If JOBV = 'N', V is not referenced.

           LDV

                     LDV is INTEGER
                     The leading dimension of the array V. LDV >= max(1,P) if
                     JOBV = 'V'; LDV >= 1 otherwise.

           Q

                     Q is COMPLEX array, dimension (LDQ,N)
                     On entry, if JOBQ = 'Q', Q must contain a matrix Q1 (usually
                     the unitary matrix returned by CGGSVP).
                     On exit,
                     if JOBQ = 'I', Q contains the unitary matrix Q;
                     if JOBQ = 'Q', Q contains the product Q1*Q.
                     If JOBQ = 'N', Q is not referenced.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q. LDQ >= max(1,N) if
                     JOBQ = 'Q'; LDQ >= 1 otherwise.

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           NCYCLE

                     NCYCLE is INTEGER
                     The number of cycles required for convergence.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     = 1:  the procedure does not converge after MAXIT cycles.

       Internal Parameters:

             MAXIT   INTEGER
                     MAXIT specifies the total loops that the iterative procedure
                     may take. If after MAXIT cycles, the routine fails to
                     converge, we return INFO = 1.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             CTGSJA essentially uses a variant of Kogbetliantz algorithm to reduce
             min(L,M-K)-by-L triangular (or trapezoidal) matrix A23 and L-by-L
             matrix B13 to the form:

                      U1**H *A13*Q1 = C1*R1; V1**H *B13*Q1 = S1*R1,

             where U1, V1 and Q1 are unitary matrix.
             C1 and S1 are diagonal matrices satisfying

                           C1**2 + S1**2 = I,

             and R1 is an L-by-L nonsingular upper triangular matrix.

   subroutine ctgsna (character JOB, character HOWMNY, logical, dimension( * ) SELECT, integer N,
       complex, dimension( lda, * ) A, integer LDA, complex, dimension( ldb, * ) B, integer LDB,
       complex, dimension( ldvl, * ) VL, integer LDVL, complex, dimension( ldvr, * ) VR, integer
       LDVR, real, dimension( * ) S, real, dimension( * ) DIF, integer MM, integer M, complex,
       dimension( * ) WORK, integer LWORK, integer, dimension( * ) IWORK, integer INFO)
       CTGSNA

       Purpose:

            CTGSNA estimates reciprocal condition numbers for specified
            eigenvalues and/or eigenvectors of a matrix pair (A, B).

            (A, B) must be in generalized Schur canonical form, that is, A and
            B are both upper triangular.

       Parameters
           JOB

                     JOB is CHARACTER*1
                     Specifies whether condition numbers are required for
                     eigenvalues (S) or eigenvectors (DIF):
                     = 'E': for eigenvalues only (S);
                     = 'V': for eigenvectors only (DIF);
                     = 'B': for both eigenvalues and eigenvectors (S and DIF).

           HOWMNY

                     HOWMNY is CHARACTER*1
                     = 'A': compute condition numbers for all eigenpairs;
                     = 'S': compute condition numbers for selected eigenpairs
                            specified by the array SELECT.

           SELECT

                     SELECT is LOGICAL array, dimension (N)
                     If HOWMNY = 'S', SELECT specifies the eigenpairs for which
                     condition numbers are required. To select condition numbers
                     for the corresponding j-th eigenvalue and/or eigenvector,
                     SELECT(j) must be set to .TRUE..
                     If HOWMNY = 'A', SELECT is not referenced.

           N

                     N is INTEGER
                     The order of the square matrix pair (A, B). N >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     The upper triangular matrix A in the pair (A,B).

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= max(1,N).

           B

                     B is COMPLEX array, dimension (LDB,N)
                     The upper triangular matrix B in the pair (A, B).

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B. LDB >= max(1,N).

           VL

                     VL is COMPLEX array, dimension (LDVL,M)
                     IF JOB = 'E' or 'B', VL must contain left eigenvectors of
                     (A, B), corresponding to the eigenpairs specified by HOWMNY
                     and SELECT.  The eigenvectors must be stored in consecutive
                     columns of VL, as returned by CTGEVC.
                     If JOB = 'V', VL is not referenced.

           LDVL

                     LDVL is INTEGER
                     The leading dimension of the array VL. LDVL >= 1; and
                     If JOB = 'E' or 'B', LDVL >= N.

           VR

                     VR is COMPLEX array, dimension (LDVR,M)
                     IF JOB = 'E' or 'B', VR must contain right eigenvectors of
                     (A, B), corresponding to the eigenpairs specified by HOWMNY
                     and SELECT.  The eigenvectors must be stored in consecutive
                     columns of VR, as returned by CTGEVC.
                     If JOB = 'V', VR is not referenced.

           LDVR

                     LDVR is INTEGER
                     The leading dimension of the array VR. LDVR >= 1;
                     If JOB = 'E' or 'B', LDVR >= N.

           S

                     S is REAL array, dimension (MM)
                     If JOB = 'E' or 'B', the reciprocal condition numbers of the
                     selected eigenvalues, stored in consecutive elements of the
                     array.
                     If JOB = 'V', S is not referenced.

           DIF

                     DIF is REAL array, dimension (MM)
                     If JOB = 'V' or 'B', the estimated reciprocal condition
                     numbers of the selected eigenvectors, stored in consecutive
                     elements of the array.
                     If the eigenvalues cannot be reordered to compute DIF(j),
                     DIF(j) is set to 0; this can only occur when the true value
                     would be very small anyway.
                     For each eigenvalue/vector specified by SELECT, DIF stores
                     a Frobenius norm-based estimate of Difl.
                     If JOB = 'E', DIF is not referenced.

           MM

                     MM is INTEGER
                     The number of elements in the arrays S and DIF. MM >= M.

           M

                     M is INTEGER
                     The number of elements of the arrays S and DIF used to store
                     the specified condition numbers; for each selected eigenvalue
                     one element is used. If HOWMNY = 'A', M is set to N.

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK >= max(1,N).
                     If JOB = 'V' or 'B', LWORK >= max(1,2*N*N).

           IWORK

                     IWORK is INTEGER array, dimension (N+2)
                     If JOB = 'E', IWORK is not referenced.

           INFO

                     INFO is INTEGER
                     = 0: Successful exit
                     < 0: If INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The reciprocal of the condition number of the i-th generalized
             eigenvalue w = (a, b) is defined as

                     S(I) = (|v**HAu|**2 + |v**HBu|**2)**(1/2) / (norm(u)*norm(v))

             where u and v are the right and left eigenvectors of (A, B)
             corresponding to w; |z| denotes the absolute value of the complex
             number, and norm(u) denotes the 2-norm of the vector u. The pair
             (a, b) corresponds to an eigenvalue w = a/b (= v**HAu/v**HBu) of the
             matrix pair (A, B). If both a and b equal zero, then (A,B) is
             singular and S(I) = -1 is returned.

             An approximate error bound on the chordal distance between the i-th
             computed generalized eigenvalue w and the corresponding exact
             eigenvalue lambda is

                     chord(w, lambda) <=   EPS * norm(A, B) / S(I),

             where EPS is the machine precision.

             The reciprocal of the condition number of the right eigenvector u
             and left eigenvector v corresponding to the generalized eigenvalue w
             is defined as follows. Suppose

                              (A, B) = ( a   *  ) ( b  *  )  1
                                       ( 0  A22 ),( 0 B22 )  n-1
                                         1  n-1     1 n-1

             Then the reciprocal condition number DIF(I) is

                     Difl[(a, b), (A22, B22)]  = sigma-min( Zl )

             where sigma-min(Zl) denotes the smallest singular value of

                    Zl = [ kron(a, In-1) -kron(1, A22) ]
                         [ kron(b, In-1) -kron(1, B22) ].

             Here In-1 is the identity matrix of size n-1 and X**H is the conjugate
             transpose of X. kron(X, Y) is the Kronecker product between the
             matrices X and Y.

             We approximate the smallest singular value of Zl with an upper
             bound. This is done by CLATDF.

             An approximate error bound for a computed eigenvector VL(i) or
             VR(i) is given by

                                 EPS * norm(A, B) / DIF(i).

             See ref. [2-3] for more details and further references.

       Contributors:
           Bo Kagstrom and Peter Poromaa, Department of Computing Science, Umea University, S-901
           87 Umea, Sweden.

       References:

             [1] B. Kagstrom; A Direct Method for Reordering Eigenvalues in the
                 Generalized Real Schur Form of a Regular Matrix Pair (A, B), in
                 M.S. Moonen et al (eds), Linear Algebra for Large Scale and
                 Real-Time Applications, Kluwer Academic Publ. 1993, pp 195-218.

             [2] B. Kagstrom and P. Poromaa; Computing Eigenspaces with Specified
                 Eigenvalues of a Regular Matrix Pair (A, B) and Condition
                 Estimation: Theory, Algorithms and Software, Report
                 UMINF - 94.04, Department of Computing Science, Umea University,
                 S-901 87 Umea, Sweden, 1994. Also as LAPACK Working Note 87.
                 To appear in Numerical Algorithms, 1996.

             [3] B. Kagstrom and P. Poromaa, LAPACK-Style Algorithms and Software
                 for Solving the Generalized Sylvester Equation and Estimating the
                 Separation between Regular Matrix Pairs, Report UMINF - 93.23,
                 Department of Computing Science, Umea University, S-901 87 Umea,
                 Sweden, December 1993, Revised April 1994, Also as LAPACK Working
                 Note 75.
                 To appear in ACM Trans. on Math. Software, Vol 22, No 1, 1996.

   subroutine ctpcon (character NORM, character UPLO, character DIAG, integer N, complex,
       dimension( * ) AP, real RCOND, complex, dimension( * ) WORK, real, dimension( * ) RWORK,
       integer INFO)
       CTPCON

       Purpose:

            CTPCON estimates the reciprocal of the condition number of a packed
            triangular matrix A, in either the 1-norm or the infinity-norm.

            The norm of A is computed and an estimate is obtained for
            norm(inv(A)), then the reciprocal of the condition number is
            computed as
               RCOND = 1 / ( norm(A) * norm(inv(A)) ).

       Parameters
           NORM

                     NORM is CHARACTER*1
                     Specifies whether the 1-norm condition number or the
                     infinity-norm condition number is required:
                     = '1' or 'O':  1-norm;
                     = 'I':         Infinity-norm.

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           DIAG

                     DIAG is CHARACTER*1
                     = 'N':  A is non-unit triangular;
                     = 'U':  A is unit triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The upper or lower triangular matrix A, packed columnwise in
                     a linear array.  The j-th column of A is stored in the array
                     AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
                     If DIAG = 'U', the diagonal elements of A are not referenced
                     and are assumed to be 1.

           RCOND

                     RCOND is REAL
                     The reciprocal of the condition number of the matrix A,
                     computed as RCOND = 1/(norm(A) * norm(inv(A))).

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctpmqrt (character SIDE, character TRANS, integer M, integer N, integer K, integer
       L, integer NB, complex, dimension( ldv, * ) V, integer LDV, complex, dimension( ldt, * )
       T, integer LDT, complex, dimension( lda, * ) A, integer LDA, complex, dimension( ldb, * )
       B, integer LDB, complex, dimension( * ) WORK, integer INFO)
       CTPMQRT

       Purpose:

            CTPMQRT applies a complex orthogonal matrix Q obtained from a
            "triangular-pentagonal" complex block reflector H to a general
            complex matrix C, which consists of two blocks A and B.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left;
                     = 'R': apply Q or Q**H from the Right.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  No transpose, apply Q;
                     = 'C':  Conjugate transpose, apply Q**H.

           M

                     M is INTEGER
                     The number of rows of the matrix B. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix B. N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines
                     the matrix Q.

           L

                     L is INTEGER
                     The order of the trapezoidal part of V.
                     K >= L >= 0.  See Further Details.

           NB

                     NB is INTEGER
                     The block size used for the storage of T.  K >= NB >= 1.
                     This must be the same value of NB used to generate T
                     in CTPQRT.

           V

                     V is COMPLEX array, dimension (LDV,K)
                     The i-th column must contain the vector which defines the
                     elementary reflector H(i), for i = 1,2,...,k, as returned by
                     CTPQRT in B.  See Further Details.

           LDV

                     LDV is INTEGER
                     The leading dimension of the array V.
                     If SIDE = 'L', LDV >= max(1,M);
                     if SIDE = 'R', LDV >= max(1,N).

           T

                     T is COMPLEX array, dimension (LDT,K)
                     The upper triangular factors of the block reflectors
                     as returned by CTPQRT, stored as a NB-by-K matrix.

           LDT

                     LDT is INTEGER
                     The leading dimension of the array T.  LDT >= NB.

           A

                     A is COMPLEX array, dimension
                     (LDA,N) if SIDE = 'L' or
                     (LDA,K) if SIDE = 'R'
                     On entry, the K-by-N or M-by-K matrix A.
                     On exit, A is overwritten by the corresponding block of
                     Q*C or Q**H*C or C*Q or C*Q**H.  See Further Details.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.
                     If SIDE = 'L', LDC >= max(1,K);
                     If SIDE = 'R', LDC >= max(1,M).

           B

                     B is COMPLEX array, dimension (LDB,N)
                     On entry, the M-by-N matrix B.
                     On exit, B is overwritten by the corresponding block of
                     Q*C or Q**H*C or C*Q or C*Q**H.  See Further Details.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.
                     LDB >= max(1,M).

           WORK

                     WORK is COMPLEX array. The dimension of WORK is
                      N*NB if SIDE = 'L', or  M*NB if SIDE = 'R'.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The columns of the pentagonal matrix V contain the elementary reflectors
             H(1), H(2), ..., H(K); V is composed of a rectangular block V1 and a
             trapezoidal block V2:

                   V = [V1]
                       [V2].

             The size of the trapezoidal block V2 is determined by the parameter L,
             where 0 <= L <= K; V2 is upper trapezoidal, consisting of the first L
             rows of a K-by-K upper triangular matrix.  If L=K, V2 is upper triangular;
             if L=0, there is no trapezoidal block, hence V = V1 is rectangular.

             If SIDE = 'L':  C = [A]  where A is K-by-N,  B is M-by-N and V is M-by-K.
                                 [B]

             If SIDE = 'R':  C = [A B]  where A is M-by-K, B is M-by-N and V is N-by-K.

             The complex orthogonal matrix Q is formed from V and T.

             If TRANS='N' and SIDE='L', C is on exit replaced with Q * C.

             If TRANS='C' and SIDE='L', C is on exit replaced with Q**H * C.

             If TRANS='N' and SIDE='R', C is on exit replaced with C * Q.

             If TRANS='C' and SIDE='R', C is on exit replaced with C * Q**H.

   subroutine ctpqrt (integer M, integer N, integer L, integer NB, complex, dimension( lda, * )
       A, integer LDA, complex, dimension( ldb, * ) B, integer LDB, complex, dimension( ldt, * )
       T, integer LDT, complex, dimension( * ) WORK, integer INFO)
       CTPQRT

       Purpose:

            CTPQRT computes a blocked QR factorization of a complex
            "triangular-pentagonal" matrix C, which is composed of a
            triangular block A and pentagonal block B, using the compact
            WY representation for Q.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix B.
                     M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix B, and the order of the
                     triangular matrix A.
                     N >= 0.

           L

                     L is INTEGER
                     The number of rows of the upper trapezoidal part of B.
                     MIN(M,N) >= L >= 0.  See Further Details.

           NB

                     NB is INTEGER
                     The block size to be used in the blocked QR.  N >= NB >= 1.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the upper triangular N-by-N matrix A.
                     On exit, the elements on and above the diagonal of the array
                     contain the upper triangular matrix R.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           B

                     B is COMPLEX array, dimension (LDB,N)
                     On entry, the pentagonal M-by-N matrix B.  The first M-L rows
                     are rectangular, and the last L rows are upper trapezoidal.
                     On exit, B contains the pentagonal matrix V.  See Further Details.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,M).

           T

                     T is COMPLEX array, dimension (LDT,N)
                     The upper triangular block reflectors stored in compact form
                     as a sequence of upper triangular blocks.  See Further Details.

           LDT

                     LDT is INTEGER
                     The leading dimension of the array T.  LDT >= NB.

           WORK

                     WORK is COMPLEX array, dimension (NB*N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The input matrix C is a (N+M)-by-N matrix

                          C = [ A ]
                              [ B ]

             where A is an upper triangular N-by-N matrix, and B is M-by-N pentagonal
             matrix consisting of a (M-L)-by-N rectangular matrix B1 on top of a L-by-N
             upper trapezoidal matrix B2:

                          B = [ B1 ]  <- (M-L)-by-N rectangular
                              [ B2 ]  <-     L-by-N upper trapezoidal.

             The upper trapezoidal matrix B2 consists of the first L rows of a
             N-by-N upper triangular matrix, where 0 <= L <= MIN(M,N).  If L=0,
             B is rectangular M-by-N; if M=L=N, B is upper triangular.

             The matrix W stores the elementary reflectors H(i) in the i-th column
             below the diagonal (of A) in the (N+M)-by-N input matrix C

                          C = [ A ]  <- upper triangular N-by-N
                              [ B ]  <- M-by-N pentagonal

             so that W can be represented as

                          W = [ I ]  <- identity, N-by-N
                              [ V ]  <- M-by-N, same form as B.

             Thus, all of information needed for W is contained on exit in B, which
             we call V above.  Note that V has the same form as B; that is,

                          V = [ V1 ] <- (M-L)-by-N rectangular
                              [ V2 ] <-     L-by-N upper trapezoidal.

             The columns of V represent the vectors which define the H(i)'s.

             The number of blocks is B = ceiling(N/NB), where each
             block is of order NB except for the last block, which is of order
             IB = N - (B-1)*NB.  For each of the B blocks, a upper triangular block
             reflector factor is computed: T1, T2, ..., TB.  The NB-by-NB (and IB-by-IB
             for the last block) T's are stored in the NB-by-N matrix T as

                          T = [T1 T2 ... TB].

   subroutine ctpqrt2 (integer M, integer N, integer L, complex, dimension( lda, * ) A, integer
       LDA, complex, dimension( ldb, * ) B, integer LDB, complex, dimension( ldt, * ) T, integer
       LDT, integer INFO)
       CTPQRT2 computes a QR factorization of a real or complex 'triangular-pentagonal' matrix,
       which is composed of a triangular block and a pentagonal block, using the compact WY
       representation for Q.

       Purpose:

            CTPQRT2 computes a QR factorization of a complex "triangular-pentagonal"
            matrix C, which is composed of a triangular block A and pentagonal block B,
            using the compact WY representation for Q.

       Parameters
           M

                     M is INTEGER
                     The total number of rows of the matrix B.
                     M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix B, and the order of
                     the triangular matrix A.
                     N >= 0.

           L

                     L is INTEGER
                     The number of rows of the upper trapezoidal part of B.
                     MIN(M,N) >= L >= 0.  See Further Details.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the upper triangular N-by-N matrix A.
                     On exit, the elements on and above the diagonal of the array
                     contain the upper triangular matrix R.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           B

                     B is COMPLEX array, dimension (LDB,N)
                     On entry, the pentagonal M-by-N matrix B.  The first M-L rows
                     are rectangular, and the last L rows are upper trapezoidal.
                     On exit, B contains the pentagonal matrix V.  See Further Details.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,M).

           T

                     T is COMPLEX array, dimension (LDT,N)
                     The N-by-N upper triangular factor T of the block reflector.
                     See Further Details.

           LDT

                     LDT is INTEGER
                     The leading dimension of the array T.  LDT >= max(1,N)

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The input matrix C is a (N+M)-by-N matrix

                          C = [ A ]
                              [ B ]

             where A is an upper triangular N-by-N matrix, and B is M-by-N pentagonal
             matrix consisting of a (M-L)-by-N rectangular matrix B1 on top of a L-by-N
             upper trapezoidal matrix B2:

                          B = [ B1 ]  <- (M-L)-by-N rectangular
                              [ B2 ]  <-     L-by-N upper trapezoidal.

             The upper trapezoidal matrix B2 consists of the first L rows of a
             N-by-N upper triangular matrix, where 0 <= L <= MIN(M,N).  If L=0,
             B is rectangular M-by-N; if M=L=N, B is upper triangular.

             The matrix W stores the elementary reflectors H(i) in the i-th column
             below the diagonal (of A) in the (N+M)-by-N input matrix C

                          C = [ A ]  <- upper triangular N-by-N
                              [ B ]  <- M-by-N pentagonal

             so that W can be represented as

                          W = [ I ]  <- identity, N-by-N
                              [ V ]  <- M-by-N, same form as B.

             Thus, all of information needed for W is contained on exit in B, which
             we call V above.  Note that V has the same form as B; that is,

                          V = [ V1 ] <- (M-L)-by-N rectangular
                              [ V2 ] <-     L-by-N upper trapezoidal.

             The columns of V represent the vectors which define the H(i)'s.
             The (M+N)-by-(M+N) block reflector H is then given by

                          H = I - W * T * W**H

             where W**H is the conjugate transpose of W and T is the upper triangular
             factor of the block reflector.

   subroutine ctprfs (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex, dimension( * ) AP, complex, dimension( ldb, * ) B, integer LDB, complex,
       dimension( ldx, * ) X, integer LDX, real, dimension( * ) FERR, real, dimension( * ) BERR,
       complex, dimension( * ) WORK, real, dimension( * ) RWORK, integer INFO)
       CTPRFS

       Purpose:

            CTPRFS provides error bounds and backward error estimates for the
            solution to a system of linear equations with a triangular packed
            coefficient matrix.

            The solution matrix X must be computed by CTPTRS or some other
            means before entering this routine.  CTPRFS does not do iterative
            refinement because doing so cannot improve the backward error.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations:
                     = 'N':  A * X = B     (No transpose)
                     = 'T':  A**T * X = B  (Transpose)
                     = 'C':  A**H * X = B  (Conjugate transpose)

           DIAG

                     DIAG is CHARACTER*1
                     = 'N':  A is non-unit triangular;
                     = 'U':  A is unit triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrices B and X.  NRHS >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The upper or lower triangular matrix A, packed columnwise in
                     a linear array.  The j-th column of A is stored in the array
                     AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
                     If DIAG = 'U', the diagonal elements of A are not referenced
                     and are assumed to be 1.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     The right hand side matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           X

                     X is COMPLEX array, dimension (LDX,NRHS)
                     The solution matrix X.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  LDX >= max(1,N).

           FERR

                     FERR is REAL array, dimension (NRHS)
                     The estimated forward error bound for each solution vector
                     X(j) (the j-th column of the solution matrix X).
                     If XTRUE is the true solution corresponding to X(j), FERR(j)
                     is an estimated upper bound for the magnitude of the largest
                     element in (X(j) - XTRUE) divided by the magnitude of the
                     largest element in X(j).  The estimate is as reliable as
                     the estimate for RCOND, and is almost always a slight
                     overestimate of the true error.

           BERR

                     BERR is REAL array, dimension (NRHS)
                     The componentwise relative backward error of each solution
                     vector X(j) (i.e., the smallest relative change in
                     any element of A or B that makes X(j) an exact solution).

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctptri (character UPLO, character DIAG, integer N, complex, dimension( * ) AP,
       integer INFO)
       CTPTRI

       Purpose:

            CTPTRI computes the inverse of a complex upper or lower triangular
            matrix A stored in packed format.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           DIAG

                     DIAG is CHARACTER*1
                     = 'N':  A is non-unit triangular;
                     = 'U':  A is unit triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     On entry, the upper or lower triangular matrix A, stored
                     columnwise in a linear array.  The j-th column of A is stored
                     in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*((2*n-j)/2) = A(i,j) for j<=i<=n.
                     See below for further details.
                     On exit, the (triangular) inverse of the original matrix, in
                     the same packed storage format.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value
                     > 0:  if INFO = i, A(i,i) is exactly zero.  The triangular
                           matrix is singular and its inverse can not be computed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             A triangular matrix A can be transferred to packed storage using one
             of the following program segments:

             UPLO = 'U':                      UPLO = 'L':

                   JC = 1                           JC = 1
                   DO 2 J = 1, N                    DO 2 J = 1, N
                      DO 1 I = 1, J                    DO 1 I = J, N
                         AP(JC+I-1) = A(I,J)              AP(JC+I-J) = A(I,J)
                 1    CONTINUE                    1    CONTINUE
                      JC = JC + J                      JC = JC + N - J + 1
                 2 CONTINUE                       2 CONTINUE

   subroutine ctptrs (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex, dimension( * ) AP, complex, dimension( ldb, * ) B, integer LDB, integer INFO)
       CTPTRS

       Purpose:

            CTPTRS solves a triangular system of the form

               A * X = B,  A**T * X = B,  or  A**H * X = B,

            where A is a triangular matrix of order N stored in packed format,
            and B is an N-by-NRHS matrix.  A check is made to verify that A is
            nonsingular.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations:
                     = 'N':  A * X = B     (No transpose)
                     = 'T':  A**T * X = B  (Transpose)
                     = 'C':  A**H * X = B  (Conjugate transpose)

           DIAG

                     DIAG is CHARACTER*1
                     = 'N':  A is non-unit triangular;
                     = 'U':  A is unit triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrix B.  NRHS >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The upper or lower triangular matrix A, packed columnwise in
                     a linear array.  The j-th column of A is stored in the array
                     AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2*n-j)/2) = A(i,j) for j<=i<=n.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     On entry, the right hand side matrix B.
                     On exit, if INFO = 0, the solution matrix X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value
                     > 0:  if INFO = i, the i-th diagonal element of A is zero,
                           indicating that the matrix is singular and the
                           solutions X have not been computed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctpttf (character TRANSR, character UPLO, integer N, complex, dimension( 0: * ) AP,
       complex, dimension( 0: * ) ARF, integer INFO)
       CTPTTF copies a triangular matrix from the standard packed format (TP) to the rectangular
       full packed format (TF).

       Purpose:

            CTPTTF copies a triangular matrix A from standard packed format (TP)
            to rectangular full packed format (TF).

       Parameters
           TRANSR

                     TRANSR is CHARACTER*1
                     = 'N':  ARF in Normal format is wanted;
                     = 'C':  ARF in Conjugate-transpose format is wanted.

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           AP

                     AP is COMPLEX array, dimension ( N*(N+1)/2 ),
                     On entry, the upper or lower triangular matrix A, packed
                     columnwise in a linear array. The j-th column of A is stored
                     in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

           ARF

                     ARF is COMPLEX array, dimension ( N*(N+1)/2 ),
                     On exit, the upper or lower triangular matrix A stored in
                     RFP format. For a further discussion see Notes below.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             We first consider Standard Packed Format when N is even.
             We give an example where N = 6.

                 AP is Upper             AP is Lower

              00 01 02 03 04 05       00
                 11 12 13 14 15       10 11
                    22 23 24 25       20 21 22
                       33 34 35       30 31 32 33
                          44 45       40 41 42 43 44
                             55       50 51 52 53 54 55

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last
             three columns of AP upper. The lower triangle A(4:6,0:2) consists of
             conjugate-transpose of the first three columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:2,0:2) consists of
             conjugate-transpose of the last three columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N even and TRANSR = 'N'.

                    RFP A                   RFP A

                                           -- -- --
                   03 04 05                33 43 53
                                              -- --
                   13 14 15                00 44 54
                                                 --
                   23 24 25                10 11 55

                   33 34 35                20 21 22
                   --
                   00 44 45                30 31 32
                   -- --
                   01 11 55                40 41 42
                   -- -- --
                   02 12 22                50 51 52

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- -- --                -- -- -- -- -- --
                03 13 23 33 00 01 02    33 00 10 20 30 40 50
                -- -- -- -- --                -- -- -- -- --
                04 14 24 34 44 11 12    43 44 11 21 31 41 51
                -- -- -- -- -- --                -- -- -- --
                05 15 25 35 45 55 22    53 54 55 22 32 42 52

             We next  consider Standard Packed Format when N is odd.
             We give an example where N = 5.

                AP is Upper                 AP is Lower

              00 01 02 03 04              00
                 11 12 13 14              10 11
                    22 23 24              20 21 22
                       33 34              30 31 32 33
                          44              40 41 42 43 44

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last
             three columns of AP upper. The lower triangle A(3:4,0:1) consists of
             conjugate-transpose of the first two   columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:1,1:2) consists of
             conjugate-transpose of the last two   columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N odd  and TRANSR = 'N'.

                    RFP A                   RFP A

                                              -- --
                   02 03 04                00 33 43
                                                 --
                   12 13 14                10 11 44

                   22 23 24                20 21 22
                   --
                   00 33 34                30 31 32
                   -- --
                   01 11 44                40 41 42

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- --                   -- -- -- -- -- --
                02 12 22 00 01             00 10 20 30 40 50
                -- -- -- --                   -- -- -- -- --
                03 13 23 33 11             33 11 21 31 41 51
                -- -- -- -- --                   -- -- -- --
                04 14 24 34 44             43 44 22 32 42 52

   subroutine ctpttr (character UPLO, integer N, complex, dimension( * ) AP, complex, dimension(
       lda, * ) A, integer LDA, integer INFO)
       CTPTTR copies a triangular matrix from the standard packed format (TP) to the standard
       full format (TR).

       Purpose:

            CTPTTR copies a triangular matrix A from standard packed format (TP)
            to standard full format (TR).

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular.
                     = 'L':  A is lower triangular.

           N

                     N is INTEGER
                     The order of the matrix A. N >= 0.

           AP

                     AP is COMPLEX array, dimension ( N*(N+1)/2 ),
                     On entry, the upper or lower triangular matrix A, packed
                     columnwise in a linear array. The j-th column of A is stored
                     in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

           A

                     A is COMPLEX array, dimension ( LDA, N )
                     On exit, the triangular matrix A.  If UPLO = 'U', the leading
                     N-by-N upper triangular part of A contains the upper
                     triangular part of the matrix A, and the strictly lower
                     triangular part of A is not referenced.  If UPLO = 'L', the
                     leading N-by-N lower triangular part of A contains the lower
                     triangular part of the matrix A, and the strictly upper
                     triangular part of A is not referenced.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctrcon (character NORM, character UPLO, character DIAG, integer N, complex,
       dimension( lda, * ) A, integer LDA, real RCOND, complex, dimension( * ) WORK, real,
       dimension( * ) RWORK, integer INFO)
       CTRCON

       Purpose:

            CTRCON estimates the reciprocal of the condition number of a
            triangular matrix A, in either the 1-norm or the infinity-norm.

            The norm of A is computed and an estimate is obtained for
            norm(inv(A)), then the reciprocal of the condition number is
            computed as
               RCOND = 1 / ( norm(A) * norm(inv(A)) ).

       Parameters
           NORM

                     NORM is CHARACTER*1
                     Specifies whether the 1-norm condition number or the
                     infinity-norm condition number is required:
                     = '1' or 'O':  1-norm;
                     = 'I':         Infinity-norm.

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           DIAG

                     DIAG is CHARACTER*1
                     = 'N':  A is non-unit triangular;
                     = 'U':  A is unit triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     The triangular matrix A.  If UPLO = 'U', the leading N-by-N
                     upper triangular part of the array A contains the upper
                     triangular matrix, and the strictly lower triangular part of
                     A is not referenced.  If UPLO = 'L', the leading N-by-N lower
                     triangular part of the array A contains the lower triangular
                     matrix, and the strictly upper triangular part of A is not
                     referenced.  If DIAG = 'U', the diagonal elements of A are
                     also not referenced and are assumed to be 1.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           RCOND

                     RCOND is REAL
                     The reciprocal of the condition number of the matrix A,
                     computed as RCOND = 1/(norm(A) * norm(inv(A))).

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctrevc (character SIDE, character HOWMNY, logical, dimension( * ) SELECT, integer
       N, complex, dimension( ldt, * ) T, integer LDT, complex, dimension( ldvl, * ) VL, integer
       LDVL, complex, dimension( ldvr, * ) VR, integer LDVR, integer MM, integer M, complex,
       dimension( * ) WORK, real, dimension( * ) RWORK, integer INFO)
       CTREVC

       Purpose:

            CTREVC computes some or all of the right and/or left eigenvectors of
            a complex upper triangular matrix T.
            Matrices of this type are produced by the Schur factorization of
            a complex general matrix:  A = Q*T*Q**H, as computed by CHSEQR.

            The right eigenvector x and the left eigenvector y of T corresponding
            to an eigenvalue w are defined by:

                         T*x = w*x,     (y**H)*T = w*(y**H)

            where y**H denotes the conjugate transpose of the vector y.
            The eigenvalues are not input to this routine, but are read directly
            from the diagonal of T.

            This routine returns the matrices X and/or Y of right and left
            eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an
            input matrix.  If Q is the unitary factor that reduces a matrix A to
            Schur form T, then Q*X and Q*Y are the matrices of right and left
            eigenvectors of A.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'R':  compute right eigenvectors only;
                     = 'L':  compute left eigenvectors only;
                     = 'B':  compute both right and left eigenvectors.

           HOWMNY

                     HOWMNY is CHARACTER*1
                     = 'A':  compute all right and/or left eigenvectors;
                     = 'B':  compute all right and/or left eigenvectors,
                             backtransformed using the matrices supplied in
                             VR and/or VL;
                     = 'S':  compute selected right and/or left eigenvectors,
                             as indicated by the logical array SELECT.

           SELECT

                     SELECT is LOGICAL array, dimension (N)
                     If HOWMNY = 'S', SELECT specifies the eigenvectors to be
                     computed.
                     The eigenvector corresponding to the j-th eigenvalue is
                     computed if SELECT(j) = .TRUE..
                     Not referenced if HOWMNY = 'A' or 'B'.

           N

                     N is INTEGER
                     The order of the matrix T. N >= 0.

           T

                     T is COMPLEX array, dimension (LDT,N)
                     The upper triangular matrix T.  T is modified, but restored
                     on exit.

           LDT

                     LDT is INTEGER
                     The leading dimension of the array T. LDT >= max(1,N).

           VL

                     VL is COMPLEX array, dimension (LDVL,MM)
                     On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must
                     contain an N-by-N matrix Q (usually the unitary matrix Q of
                     Schur vectors returned by CHSEQR).
                     On exit, if SIDE = 'L' or 'B', VL contains:
                     if HOWMNY = 'A', the matrix Y of left eigenvectors of T;
                     if HOWMNY = 'B', the matrix Q*Y;
                     if HOWMNY = 'S', the left eigenvectors of T specified by
                                      SELECT, stored consecutively in the columns
                                      of VL, in the same order as their
                                      eigenvalues.
                     Not referenced if SIDE = 'R'.

           LDVL

                     LDVL is INTEGER
                     The leading dimension of the array VL.  LDVL >= 1, and if
                     SIDE = 'L' or 'B', LDVL >= N.

           VR

                     VR is COMPLEX array, dimension (LDVR,MM)
                     On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must
                     contain an N-by-N matrix Q (usually the unitary matrix Q of
                     Schur vectors returned by CHSEQR).
                     On exit, if SIDE = 'R' or 'B', VR contains:
                     if HOWMNY = 'A', the matrix X of right eigenvectors of T;
                     if HOWMNY = 'B', the matrix Q*X;
                     if HOWMNY = 'S', the right eigenvectors of T specified by
                                      SELECT, stored consecutively in the columns
                                      of VR, in the same order as their
                                      eigenvalues.
                     Not referenced if SIDE = 'L'.

           LDVR

                     LDVR is INTEGER
                     The leading dimension of the array VR.  LDVR >= 1, and if
                     SIDE = 'R' or 'B'; LDVR >= N.

           MM

                     MM is INTEGER
                     The number of columns in the arrays VL and/or VR. MM >= M.

           M

                     M is INTEGER
                     The number of columns in the arrays VL and/or VR actually
                     used to store the eigenvectors.  If HOWMNY = 'A' or 'B', M
                     is set to N.  Each selected eigenvector occupies one
                     column.

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The algorithm used in this program is basically backward (forward)
             substitution, with scaling to make the the code robust against
             possible overflow.

             Each eigenvector is normalized so that the element of largest
             magnitude has magnitude 1; here the magnitude of a complex number
             (x,y) is taken to be |x| + |y|.

   subroutine ctrevc3 (character SIDE, character HOWMNY, logical, dimension( * ) SELECT, integer
       N, complex, dimension( ldt, * ) T, integer LDT, complex, dimension( ldvl, * ) VL, integer
       LDVL, complex, dimension( ldvr, * ) VR, integer LDVR, integer MM, integer M, complex,
       dimension( * ) WORK, integer LWORK, real, dimension( * ) RWORK, integer LRWORK, integer
       INFO)
       CTREVC3

       Purpose:

            CTREVC3 computes some or all of the right and/or left eigenvectors of
            a complex upper triangular matrix T.
            Matrices of this type are produced by the Schur factorization of
            a complex general matrix:  A = Q*T*Q**H, as computed by CHSEQR.

            The right eigenvector x and the left eigenvector y of T corresponding
            to an eigenvalue w are defined by:

                         T*x = w*x,     (y**H)*T = w*(y**H)

            where y**H denotes the conjugate transpose of the vector y.
            The eigenvalues are not input to this routine, but are read directly
            from the diagonal of T.

            This routine returns the matrices X and/or Y of right and left
            eigenvectors of T, or the products Q*X and/or Q*Y, where Q is an
            input matrix. If Q is the unitary factor that reduces a matrix A to
            Schur form T, then Q*X and Q*Y are the matrices of right and left
            eigenvectors of A.

            This uses a Level 3 BLAS version of the back transformation.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'R':  compute right eigenvectors only;
                     = 'L':  compute left eigenvectors only;
                     = 'B':  compute both right and left eigenvectors.

           HOWMNY

                     HOWMNY is CHARACTER*1
                     = 'A':  compute all right and/or left eigenvectors;
                     = 'B':  compute all right and/or left eigenvectors,
                             backtransformed using the matrices supplied in
                             VR and/or VL;
                     = 'S':  compute selected right and/or left eigenvectors,
                             as indicated by the logical array SELECT.

           SELECT

                     SELECT is LOGICAL array, dimension (N)
                     If HOWMNY = 'S', SELECT specifies the eigenvectors to be
                     computed.
                     The eigenvector corresponding to the j-th eigenvalue is
                     computed if SELECT(j) = .TRUE..
                     Not referenced if HOWMNY = 'A' or 'B'.

           N

                     N is INTEGER
                     The order of the matrix T. N >= 0.

           T

                     T is COMPLEX array, dimension (LDT,N)
                     The upper triangular matrix T.  T is modified, but restored
                     on exit.

           LDT

                     LDT is INTEGER
                     The leading dimension of the array T. LDT >= max(1,N).

           VL

                     VL is COMPLEX array, dimension (LDVL,MM)
                     On entry, if SIDE = 'L' or 'B' and HOWMNY = 'B', VL must
                     contain an N-by-N matrix Q (usually the unitary matrix Q of
                     Schur vectors returned by CHSEQR).
                     On exit, if SIDE = 'L' or 'B', VL contains:
                     if HOWMNY = 'A', the matrix Y of left eigenvectors of T;
                     if HOWMNY = 'B', the matrix Q*Y;
                     if HOWMNY = 'S', the left eigenvectors of T specified by
                                      SELECT, stored consecutively in the columns
                                      of VL, in the same order as their
                                      eigenvalues.
                     Not referenced if SIDE = 'R'.

           LDVL

                     LDVL is INTEGER
                     The leading dimension of the array VL.
                     LDVL >= 1, and if SIDE = 'L' or 'B', LDVL >= N.

           VR

                     VR is COMPLEX array, dimension (LDVR,MM)
                     On entry, if SIDE = 'R' or 'B' and HOWMNY = 'B', VR must
                     contain an N-by-N matrix Q (usually the unitary matrix Q of
                     Schur vectors returned by CHSEQR).
                     On exit, if SIDE = 'R' or 'B', VR contains:
                     if HOWMNY = 'A', the matrix X of right eigenvectors of T;
                     if HOWMNY = 'B', the matrix Q*X;
                     if HOWMNY = 'S', the right eigenvectors of T specified by
                                      SELECT, stored consecutively in the columns
                                      of VR, in the same order as their
                                      eigenvalues.
                     Not referenced if SIDE = 'L'.

           LDVR

                     LDVR is INTEGER
                     The leading dimension of the array VR.
                     LDVR >= 1, and if SIDE = 'R' or 'B', LDVR >= N.

           MM

                     MM is INTEGER
                     The number of columns in the arrays VL and/or VR. MM >= M.

           M

                     M is INTEGER
                     The number of columns in the arrays VL and/or VR actually
                     used to store the eigenvectors.
                     If HOWMNY = 'A' or 'B', M is set to N.
                     Each selected eigenvector occupies one column.

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))

           LWORK

                     LWORK is INTEGER
                     The dimension of array WORK. LWORK >= max(1,2*N).
                     For optimum performance, LWORK >= N + 2*N*NB, where NB is
                     the optimal blocksize.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           RWORK

                     RWORK is REAL array, dimension (LRWORK)

           LRWORK

                     LRWORK is INTEGER
                     The dimension of array RWORK. LRWORK >= max(1,N).

                     If LRWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the RWORK array, returns
                     this value as the first entry of the RWORK array, and no error
                     message related to LRWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The algorithm used in this program is basically backward (forward)
             substitution, with scaling to make the the code robust against
             possible overflow.

             Each eigenvector is normalized so that the element of largest
             magnitude has magnitude 1; here the magnitude of a complex number
             (x,y) is taken to be |x| + |y|.

   subroutine ctrexc (character COMPQ, integer N, complex, dimension( ldt, * ) T, integer LDT,
       complex, dimension( ldq, * ) Q, integer LDQ, integer IFST, integer ILST, integer INFO)
       CTREXC

       Purpose:

            CTREXC reorders the Schur factorization of a complex matrix
            A = Q*T*Q**H, so that the diagonal element of T with row index IFST
            is moved to row ILST.

            The Schur form T is reordered by a unitary similarity transformation
            Z**H*T*Z, and optionally the matrix Q of Schur vectors is updated by
            postmultplying it with Z.

       Parameters
           COMPQ

                     COMPQ is CHARACTER*1
                     = 'V':  update the matrix Q of Schur vectors;
                     = 'N':  do not update Q.

           N

                     N is INTEGER
                     The order of the matrix T. N >= 0.
                     If N == 0 arguments ILST and IFST may be any value.

           T

                     T is COMPLEX array, dimension (LDT,N)
                     On entry, the upper triangular matrix T.
                     On exit, the reordered upper triangular matrix.

           LDT

                     LDT is INTEGER
                     The leading dimension of the array T. LDT >= max(1,N).

           Q

                     Q is COMPLEX array, dimension (LDQ,N)
                     On entry, if COMPQ = 'V', the matrix Q of Schur vectors.
                     On exit, if COMPQ = 'V', Q has been postmultiplied by the
                     unitary transformation matrix Z which reorders T.
                     If COMPQ = 'N', Q is not referenced.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q.  LDQ >= 1, and if
                     COMPQ = 'V', LDQ >= max(1,N).

           IFST

                     IFST is INTEGER

           ILST

                     ILST is INTEGER

                     Specify the reordering of the diagonal elements of T:
                     The element with row index IFST is moved to row ILST by a
                     sequence of transpositions between adjacent elements.
                     1 <= IFST <= N; 1 <= ILST <= N.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctrrfs (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex, dimension( lda, * ) A, integer LDA, complex, dimension( ldb, * ) B, integer LDB,
       complex, dimension( ldx, * ) X, integer LDX, real, dimension( * ) FERR, real, dimension( *
       ) BERR, complex, dimension( * ) WORK, real, dimension( * ) RWORK, integer INFO)
       CTRRFS

       Purpose:

            CTRRFS provides error bounds and backward error estimates for the
            solution to a system of linear equations with a triangular
            coefficient matrix.

            The solution matrix X must be computed by CTRTRS or some other
            means before entering this routine.  CTRRFS does not do iterative
            refinement because doing so cannot improve the backward error.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations:
                     = 'N':  A * X = B     (No transpose)
                     = 'T':  A**T * X = B  (Transpose)
                     = 'C':  A**H * X = B  (Conjugate transpose)

           DIAG

                     DIAG is CHARACTER*1
                     = 'N':  A is non-unit triangular;
                     = 'U':  A is unit triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrices B and X.  NRHS >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     The triangular matrix A.  If UPLO = 'U', the leading N-by-N
                     upper triangular part of the array A contains the upper
                     triangular matrix, and the strictly lower triangular part of
                     A is not referenced.  If UPLO = 'L', the leading N-by-N lower
                     triangular part of the array A contains the lower triangular
                     matrix, and the strictly upper triangular part of A is not
                     referenced.  If DIAG = 'U', the diagonal elements of A are
                     also not referenced and are assumed to be 1.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     The right hand side matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           X

                     X is COMPLEX array, dimension (LDX,NRHS)
                     The solution matrix X.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  LDX >= max(1,N).

           FERR

                     FERR is REAL array, dimension (NRHS)
                     The estimated forward error bound for each solution vector
                     X(j) (the j-th column of the solution matrix X).
                     If XTRUE is the true solution corresponding to X(j), FERR(j)
                     is an estimated upper bound for the magnitude of the largest
                     element in (X(j) - XTRUE) divided by the magnitude of the
                     largest element in X(j).  The estimate is as reliable as
                     the estimate for RCOND, and is almost always a slight
                     overestimate of the true error.

           BERR

                     BERR is REAL array, dimension (NRHS)
                     The componentwise relative backward error of each solution
                     vector X(j) (i.e., the smallest relative change in
                     any element of A or B that makes X(j) an exact solution).

           WORK

                     WORK is COMPLEX array, dimension (2*N)

           RWORK

                     RWORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctrsen (character JOB, character COMPQ, logical, dimension( * ) SELECT, integer N,
       complex, dimension( ldt, * ) T, integer LDT, complex, dimension( ldq, * ) Q, integer LDQ,
       complex, dimension( * ) W, integer M, real S, real SEP, complex, dimension( * ) WORK,
       integer LWORK, integer INFO)
       CTRSEN

       Purpose:

            CTRSEN reorders the Schur factorization of a complex matrix
            A = Q*T*Q**H, so that a selected cluster of eigenvalues appears in
            the leading positions on the diagonal of the upper triangular matrix
            T, and the leading columns of Q form an orthonormal basis of the
            corresponding right invariant subspace.

            Optionally the routine computes the reciprocal condition numbers of
            the cluster of eigenvalues and/or the invariant subspace.

       Parameters
           JOB

                     JOB is CHARACTER*1
                     Specifies whether condition numbers are required for the
                     cluster of eigenvalues (S) or the invariant subspace (SEP):
                     = 'N': none;
                     = 'E': for eigenvalues only (S);
                     = 'V': for invariant subspace only (SEP);
                     = 'B': for both eigenvalues and invariant subspace (S and
                            SEP).

           COMPQ

                     COMPQ is CHARACTER*1
                     = 'V': update the matrix Q of Schur vectors;
                     = 'N': do not update Q.

           SELECT

                     SELECT is LOGICAL array, dimension (N)
                     SELECT specifies the eigenvalues in the selected cluster. To
                     select the j-th eigenvalue, SELECT(j) must be set to .TRUE..

           N

                     N is INTEGER
                     The order of the matrix T. N >= 0.

           T

                     T is COMPLEX array, dimension (LDT,N)
                     On entry, the upper triangular matrix T.
                     On exit, T is overwritten by the reordered matrix T, with the
                     selected eigenvalues as the leading diagonal elements.

           LDT

                     LDT is INTEGER
                     The leading dimension of the array T. LDT >= max(1,N).

           Q

                     Q is COMPLEX array, dimension (LDQ,N)
                     On entry, if COMPQ = 'V', the matrix Q of Schur vectors.
                     On exit, if COMPQ = 'V', Q has been postmultiplied by the
                     unitary transformation matrix which reorders T; the leading M
                     columns of Q form an orthonormal basis for the specified
                     invariant subspace.
                     If COMPQ = 'N', Q is not referenced.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q.
                     LDQ >= 1; and if COMPQ = 'V', LDQ >= N.

           W

                     W is COMPLEX array, dimension (N)
                     The reordered eigenvalues of T, in the same order as they
                     appear on the diagonal of T.

           M

                     M is INTEGER
                     The dimension of the specified invariant subspace.
                     0 <= M <= N.

           S

                     S is REAL
                     If JOB = 'E' or 'B', S is a lower bound on the reciprocal
                     condition number for the selected cluster of eigenvalues.
                     S cannot underestimate the true reciprocal condition number
                     by more than a factor of sqrt(N). If M = 0 or N, S = 1.
                     If JOB = 'N' or 'V', S is not referenced.

           SEP

                     SEP is REAL
                     If JOB = 'V' or 'B', SEP is the estimated reciprocal
                     condition number of the specified invariant subspace. If
                     M = 0 or N, SEP = norm(T).
                     If JOB = 'N' or 'E', SEP is not referenced.

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If JOB = 'N', LWORK >= 1;
                     if JOB = 'E', LWORK = max(1,M*(N-M));
                     if JOB = 'V' or 'B', LWORK >= max(1,2*M*(N-M)).

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             CTRSEN first collects the selected eigenvalues by computing a unitary
             transformation Z to move them to the top left corner of T. In other
             words, the selected eigenvalues are the eigenvalues of T11 in:

                     Z**H * T * Z = ( T11 T12 ) n1
                                    (  0  T22 ) n2
                                       n1  n2

             where N = n1+n2. The first
             n1 columns of Z span the specified invariant subspace of T.

             If T has been obtained from the Schur factorization of a matrix
             A = Q*T*Q**H, then the reordered Schur factorization of A is given by
             A = (Q*Z)*(Z**H*T*Z)*(Q*Z)**H, and the first n1 columns of Q*Z span the
             corresponding invariant subspace of A.

             The reciprocal condition number of the average of the eigenvalues of
             T11 may be returned in S. S lies between 0 (very badly conditioned)
             and 1 (very well conditioned). It is computed as follows. First we
             compute R so that

                                    P = ( I  R ) n1
                                        ( 0  0 ) n2
                                          n1 n2

             is the projector on the invariant subspace associated with T11.
             R is the solution of the Sylvester equation:

                                   T11*R - R*T22 = T12.

             Let F-norm(M) denote the Frobenius-norm of M and 2-norm(M) denote
             the two-norm of M. Then S is computed as the lower bound

                                 (1 + F-norm(R)**2)**(-1/2)

             on the reciprocal of 2-norm(P), the true reciprocal condition number.
             S cannot underestimate 1 / 2-norm(P) by more than a factor of
             sqrt(N).

             An approximate error bound for the computed average of the
             eigenvalues of T11 is

                                    EPS * norm(T) / S

             where EPS is the machine precision.

             The reciprocal condition number of the right invariant subspace
             spanned by the first n1 columns of Z (or of Q*Z) is returned in SEP.
             SEP is defined as the separation of T11 and T22:

                                sep( T11, T22 ) = sigma-min( C )

             where sigma-min(C) is the smallest singular value of the
             n1*n2-by-n1*n2 matrix

                C  = kprod( I(n2), T11 ) - kprod( transpose(T22), I(n1) )

             I(m) is an m by m identity matrix, and kprod denotes the Kronecker
             product. We estimate sigma-min(C) by the reciprocal of an estimate of
             the 1-norm of inverse(C). The true reciprocal 1-norm of inverse(C)
             cannot differ from sigma-min(C) by more than a factor of sqrt(n1*n2).

             When SEP is small, small changes in T can cause large changes in
             the invariant subspace. An approximate bound on the maximum angular
             error in the computed right invariant subspace is

                                 EPS * norm(T) / SEP

   subroutine ctrsna (character JOB, character HOWMNY, logical, dimension( * ) SELECT, integer N,
       complex, dimension( ldt, * ) T, integer LDT, complex, dimension( ldvl, * ) VL, integer
       LDVL, complex, dimension( ldvr, * ) VR, integer LDVR, real, dimension( * ) S, real,
       dimension( * ) SEP, integer MM, integer M, complex, dimension( ldwork, * ) WORK, integer
       LDWORK, real, dimension( * ) RWORK, integer INFO)
       CTRSNA

       Purpose:

            CTRSNA estimates reciprocal condition numbers for specified
            eigenvalues and/or right eigenvectors of a complex upper triangular
            matrix T (or of any matrix Q*T*Q**H with Q unitary).

       Parameters
           JOB

                     JOB is CHARACTER*1
                     Specifies whether condition numbers are required for
                     eigenvalues (S) or eigenvectors (SEP):
                     = 'E': for eigenvalues only (S);
                     = 'V': for eigenvectors only (SEP);
                     = 'B': for both eigenvalues and eigenvectors (S and SEP).

           HOWMNY

                     HOWMNY is CHARACTER*1
                     = 'A': compute condition numbers for all eigenpairs;
                     = 'S': compute condition numbers for selected eigenpairs
                            specified by the array SELECT.

           SELECT

                     SELECT is LOGICAL array, dimension (N)
                     If HOWMNY = 'S', SELECT specifies the eigenpairs for which
                     condition numbers are required. To select condition numbers
                     for the j-th eigenpair, SELECT(j) must be set to .TRUE..
                     If HOWMNY = 'A', SELECT is not referenced.

           N

                     N is INTEGER
                     The order of the matrix T. N >= 0.

           T

                     T is COMPLEX array, dimension (LDT,N)
                     The upper triangular matrix T.

           LDT

                     LDT is INTEGER
                     The leading dimension of the array T. LDT >= max(1,N).

           VL

                     VL is COMPLEX array, dimension (LDVL,M)
                     If JOB = 'E' or 'B', VL must contain left eigenvectors of T
                     (or of any Q*T*Q**H with Q unitary), corresponding to the
                     eigenpairs specified by HOWMNY and SELECT. The eigenvectors
                     must be stored in consecutive columns of VL, as returned by
                     CHSEIN or CTREVC.
                     If JOB = 'V', VL is not referenced.

           LDVL

                     LDVL is INTEGER
                     The leading dimension of the array VL.
                     LDVL >= 1; and if JOB = 'E' or 'B', LDVL >= N.

           VR

                     VR is COMPLEX array, dimension (LDVR,M)
                     If JOB = 'E' or 'B', VR must contain right eigenvectors of T
                     (or of any Q*T*Q**H with Q unitary), corresponding to the
                     eigenpairs specified by HOWMNY and SELECT. The eigenvectors
                     must be stored in consecutive columns of VR, as returned by
                     CHSEIN or CTREVC.
                     If JOB = 'V', VR is not referenced.

           LDVR

                     LDVR is INTEGER
                     The leading dimension of the array VR.
                     LDVR >= 1; and if JOB = 'E' or 'B', LDVR >= N.

           S

                     S is REAL array, dimension (MM)
                     If JOB = 'E' or 'B', the reciprocal condition numbers of the
                     selected eigenvalues, stored in consecutive elements of the
                     array. Thus S(j), SEP(j), and the j-th columns of VL and VR
                     all correspond to the same eigenpair (but not in general the
                     j-th eigenpair, unless all eigenpairs are selected).
                     If JOB = 'V', S is not referenced.

           SEP

                     SEP is REAL array, dimension (MM)
                     If JOB = 'V' or 'B', the estimated reciprocal condition
                     numbers of the selected eigenvectors, stored in consecutive
                     elements of the array.
                     If JOB = 'E', SEP is not referenced.

           MM

                     MM is INTEGER
                     The number of elements in the arrays S (if JOB = 'E' or 'B')
                      and/or SEP (if JOB = 'V' or 'B'). MM >= M.

           M

                     M is INTEGER
                     The number of elements of the arrays S and/or SEP actually
                     used to store the estimated condition numbers.
                     If HOWMNY = 'A', M is set to N.

           WORK

                     WORK is COMPLEX array, dimension (LDWORK,N+6)
                     If JOB = 'E', WORK is not referenced.

           LDWORK

                     LDWORK is INTEGER
                     The leading dimension of the array WORK.
                     LDWORK >= 1; and if JOB = 'V' or 'B', LDWORK >= N.

           RWORK

                     RWORK is REAL array, dimension (N)
                     If JOB = 'E', RWORK is not referenced.

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The reciprocal of the condition number of an eigenvalue lambda is
             defined as

                     S(lambda) = |v**H*u| / (norm(u)*norm(v))

             where u and v are the right and left eigenvectors of T corresponding
             to lambda; v**H denotes the conjugate transpose of v, and norm(u)
             denotes the Euclidean norm. These reciprocal condition numbers always
             lie between zero (very badly conditioned) and one (very well
             conditioned). If n = 1, S(lambda) is defined to be 1.

             An approximate error bound for a computed eigenvalue W(i) is given by

                                 EPS * norm(T) / S(i)

             where EPS is the machine precision.

             The reciprocal of the condition number of the right eigenvector u
             corresponding to lambda is defined as follows. Suppose

                         T = ( lambda  c  )
                             (   0    T22 )

             Then the reciprocal condition number is

                     SEP( lambda, T22 ) = sigma-min( T22 - lambda*I )

             where sigma-min denotes the smallest singular value. We approximate
             the smallest singular value by the reciprocal of an estimate of the
             one-norm of the inverse of T22 - lambda*I. If n = 1, SEP(1) is
             defined to be abs(T(1,1)).

             An approximate error bound for a computed right eigenvector VR(i)
             is given by

                                 EPS * norm(T) / SEP(i)

   subroutine ctrti2 (character UPLO, character DIAG, integer N, complex, dimension( lda, * ) A,
       integer LDA, integer INFO)
       CTRTI2 computes the inverse of a triangular matrix (unblocked algorithm).

       Purpose:

            CTRTI2 computes the inverse of a complex upper or lower triangular
            matrix.

            This is the Level 2 BLAS version of the algorithm.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the matrix A is upper or lower triangular.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           DIAG

                     DIAG is CHARACTER*1
                     Specifies whether or not the matrix A is unit triangular.
                     = 'N':  Non-unit triangular
                     = 'U':  Unit triangular

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the triangular matrix A.  If UPLO = 'U', the
                     leading n by n upper triangular part of the array A contains
                     the upper triangular matrix, and the strictly lower
                     triangular part of A is not referenced.  If UPLO = 'L', the
                     leading n by n lower triangular part of the array A contains
                     the lower triangular matrix, and the strictly upper
                     triangular part of A is not referenced.  If DIAG = 'U', the
                     diagonal elements of A are also not referenced and are
                     assumed to be 1.

                     On exit, the (triangular) inverse of the original matrix, in
                     the same storage format.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -k, the k-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctrtri (character UPLO, character DIAG, integer N, complex, dimension( lda, * ) A,
       integer LDA, integer INFO)
       CTRTRI

       Purpose:

            CTRTRI computes the inverse of a complex upper or lower triangular
            matrix A.

            This is the Level 3 BLAS version of the algorithm.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           DIAG

                     DIAG is CHARACTER*1
                     = 'N':  A is non-unit triangular;
                     = 'U':  A is unit triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the triangular matrix A.  If UPLO = 'U', the
                     leading N-by-N upper triangular part of the array A contains
                     the upper triangular matrix, and the strictly lower
                     triangular part of A is not referenced.  If UPLO = 'L', the
                     leading N-by-N lower triangular part of the array A contains
                     the lower triangular matrix, and the strictly upper
                     triangular part of A is not referenced.  If DIAG = 'U', the
                     diagonal elements of A are also not referenced and are
                     assumed to be 1.
                     On exit, the (triangular) inverse of the original matrix, in
                     the same storage format.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value
                     > 0: if INFO = i, A(i,i) is exactly zero.  The triangular
                          matrix is singular and its inverse can not be computed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctrtrs (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex, dimension( lda, * ) A, integer LDA, complex, dimension( ldb, * ) B, integer LDB,
       integer INFO)
       CTRTRS

       Purpose:

            CTRTRS solves a triangular system of the form

               A * X = B,  A**T * X = B,  or  A**H * X = B,

            where A is a triangular matrix of order N, and B is an N-by-NRHS
            matrix.  A check is made to verify that A is nonsingular.

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations:
                     = 'N':  A * X = B     (No transpose)
                     = 'T':  A**T * X = B  (Transpose)
                     = 'C':  A**H * X = B  (Conjugate transpose)

           DIAG

                     DIAG is CHARACTER*1
                     = 'N':  A is non-unit triangular;
                     = 'U':  A is unit triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of the matrix B.  NRHS >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     The triangular matrix A.  If UPLO = 'U', the leading N-by-N
                     upper triangular part of the array A contains the upper
                     triangular matrix, and the strictly lower triangular part of
                     A is not referenced.  If UPLO = 'L', the leading N-by-N lower
                     triangular part of the array A contains the lower triangular
                     matrix, and the strictly upper triangular part of A is not
                     referenced.  If DIAG = 'U', the diagonal elements of A are
                     also not referenced and are assumed to be 1.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     On entry, the right hand side matrix B.
                     On exit, if INFO = 0, the solution matrix X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value
                     > 0: if INFO = i, the i-th diagonal element of A is zero,
                          indicating that the matrix is singular and the solutions
                          X have not been computed.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctrttf (character TRANSR, character UPLO, integer N, complex, dimension( 0: lda-1,
       0: * ) A, integer LDA, complex, dimension( 0: * ) ARF, integer INFO)
       CTRTTF copies a triangular matrix from the standard full format (TR) to the rectangular
       full packed format (TF).

       Purpose:

            CTRTTF copies a triangular matrix A from standard full format (TR)
            to rectangular full packed format (TF) .

       Parameters
           TRANSR

                     TRANSR is CHARACTER*1
                     = 'N':  ARF in Normal mode is wanted;
                     = 'C':  ARF in Conjugate Transpose mode is wanted;

           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           A

                     A is COMPLEX array, dimension ( LDA, N )
                     On entry, the triangular matrix A.  If UPLO = 'U', the
                     leading N-by-N upper triangular part of the array A contains
                     the upper triangular matrix, and the strictly lower
                     triangular part of A is not referenced.  If UPLO = 'L', the
                     leading N-by-N lower triangular part of the array A contains
                     the lower triangular matrix, and the strictly upper
                     triangular part of A is not referenced.

           LDA

                     LDA is INTEGER
                     The leading dimension of the matrix A.  LDA >= max(1,N).

           ARF

                     ARF is COMPLEX array, dimension ( N*(N+1)/2 ),
                     On exit, the upper or lower triangular matrix A stored in
                     RFP format. For a further discussion see Notes below.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             We first consider Standard Packed Format when N is even.
             We give an example where N = 6.

                 AP is Upper             AP is Lower

              00 01 02 03 04 05       00
                 11 12 13 14 15       10 11
                    22 23 24 25       20 21 22
                       33 34 35       30 31 32 33
                          44 45       40 41 42 43 44
                             55       50 51 52 53 54 55

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last
             three columns of AP upper. The lower triangle A(4:6,0:2) consists of
             conjugate-transpose of the first three columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:2,0:2) consists of
             conjugate-transpose of the last three columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N even and TRANSR = 'N'.

                    RFP A                   RFP A

                                           -- -- --
                   03 04 05                33 43 53
                                              -- --
                   13 14 15                00 44 54
                                                 --
                   23 24 25                10 11 55

                   33 34 35                20 21 22
                   --
                   00 44 45                30 31 32
                   -- --
                   01 11 55                40 41 42
                   -- -- --
                   02 12 22                50 51 52

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- -- --                -- -- -- -- -- --
                03 13 23 33 00 01 02    33 00 10 20 30 40 50
                -- -- -- -- --                -- -- -- -- --
                04 14 24 34 44 11 12    43 44 11 21 31 41 51
                -- -- -- -- -- --                -- -- -- --
                05 15 25 35 45 55 22    53 54 55 22 32 42 52

             We next  consider Standard Packed Format when N is odd.
             We give an example where N = 5.

                AP is Upper                 AP is Lower

              00 01 02 03 04              00
                 11 12 13 14              10 11
                    22 23 24              20 21 22
                       33 34              30 31 32 33
                          44              40 41 42 43 44

             Let TRANSR = 'N'. RFP holds AP as follows:
             For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last
             three columns of AP upper. The lower triangle A(3:4,0:1) consists of
             conjugate-transpose of the first two   columns of AP upper.
             For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first
             three columns of AP lower. The upper triangle A(0:1,1:2) consists of
             conjugate-transpose of the last two   columns of AP lower.
             To denote conjugate we place -- above the element. This covers the
             case N odd  and TRANSR = 'N'.

                    RFP A                   RFP A

                                              -- --
                   02 03 04                00 33 43
                                                 --
                   12 13 14                10 11 44

                   22 23 24                20 21 22
                   --
                   00 33 34                30 31 32
                   -- --
                   01 11 44                40 41 42

             Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
             transpose of RFP A above. One therefore gets:

                      RFP A                   RFP A

                -- -- --                   -- -- -- -- -- --
                02 12 22 00 01             00 10 20 30 40 50
                -- -- -- --                   -- -- -- -- --
                03 13 23 33 11             33 11 21 31 41 51
                -- -- -- -- --                   -- -- -- --
                04 14 24 34 44             43 44 22 32 42 52

   subroutine ctrttp (character UPLO, integer N, complex, dimension( lda, * ) A, integer LDA,
       complex, dimension( * ) AP, integer INFO)
       CTRTTP copies a triangular matrix from the standard full format (TR) to the standard
       packed format (TP).

       Purpose:

            CTRTTP copies a triangular matrix A from full format (TR) to standard
            packed format (TP).

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U':  A is upper triangular;
                     = 'L':  A is lower triangular.

           N

                     N is INTEGER
                     The order of the matrices AP and A.  N >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the triangular matrix A.  If UPLO = 'U', the leading
                     N-by-N upper triangular part of A contains the upper
                     triangular part of the matrix A, and the strictly lower
                     triangular part of A is not referenced.  If UPLO = 'L', the
                     leading N-by-N lower triangular part of A contains the lower
                     triangular part of the matrix A, and the strictly upper
                     triangular part of A is not referenced.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,N).

           AP

                     AP is COMPLEX array, dimension ( N*(N+1)/2 ),
                     On exit, the upper or lower triangular matrix A, packed
                     columnwise in a linear array. The j-th column of A is stored
                     in the array AP as follows:
                     if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine ctzrzf (integer M, integer N, complex, dimension( lda, * ) A, integer LDA, complex,
       dimension( * ) TAU, complex, dimension( * ) WORK, integer LWORK, integer INFO)
       CTZRZF

       Purpose:

            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.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix A.  M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix A.  N >= M.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the leading M-by-N upper trapezoidal part of the
                     array A must contain the matrix to be factorized.
                     On exit, the leading M-by-M upper triangular part of A
                     contains the upper triangular matrix R, and elements M+1 to
                     N of the first M rows of A, with the array TAU, represent the
                     unitary matrix Z as a product of M elementary reflectors.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,M).

           TAU

                     TAU is COMPLEX array, dimension (M)
                     The scalar factors of the elementary reflectors.

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.  LWORK >= max(1,M).
                     For optimum performance LWORK >= M*NB, where NB is
                     the optimal blocksize.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA

       Further Details:

             The N-by-N matrix Z can be computed by

                Z =  Z(1)*Z(2)* ... *Z(M)

             where each N-by-N Z(k) is given by

                Z(k) = I - tau(k)*v(k)*v(k)**H

             with v(k) is the kth row vector of the M-by-N matrix

                V = ( I   A(:,M+1:N) )

             I is the M-by-M identity matrix, A(:,M+1:N)
             is the output stored in A on exit from CTZRZF,
             and tau(k) is the kth element of the array TAU.

   subroutine cunbdb (character TRANS, character SIGNS, integer M, integer P, integer Q, complex,
       dimension( ldx11, * ) X11, integer LDX11, complex, dimension( ldx12, * ) X12, integer
       LDX12, complex, dimension( ldx21, * ) X21, integer LDX21, complex, dimension( ldx22, * )
       X22, integer LDX22, real, dimension( * ) THETA, real, dimension( * ) PHI, complex,
       dimension( * ) TAUP1, complex, dimension( * ) TAUP2, complex, dimension( * ) TAUQ1,
       complex, dimension( * ) TAUQ2, complex, dimension( * ) WORK, integer LWORK, integer INFO)
       CUNBDB

       Purpose:

            CUNBDB simultaneously bidiagonalizes the blocks of an M-by-M
            partitioned unitary matrix X:

                                            [ B11 | B12 0  0 ]
                [ X11 | X12 ]   [ P1 |    ] [  0  |  0 -I  0 ] [ Q1 |    ]**H
            X = [-----------] = [---------] [----------------] [---------]   .
                [ X21 | X22 ]   [    | P2 ] [ B21 | B22 0  0 ] [    | Q2 ]
                                            [  0  |  0  0  I ]

            X11 is P-by-Q. Q must be no larger than P, M-P, or M-Q. (If this is
            not the case, then X must be transposed and/or permuted. This can be
            done in constant time using the TRANS and SIGNS options. See CUNCSD
            for details.)

            The unitary matrices P1, P2, Q1, and Q2 are P-by-P, (M-P)-by-
            (M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. They are
            represented implicitly by Householder vectors.

            B11, B12, B21, and B22 are Q-by-Q bidiagonal matrices represented
            implicitly by angles THETA, PHI.

       Parameters
           TRANS

                     TRANS is CHARACTER
                     = 'T':      X, U1, U2, V1T, and V2T are stored in row-major
                                 order;
                     otherwise:  X, U1, U2, V1T, and V2T are stored in column-
                                 major order.

           SIGNS

                     SIGNS is CHARACTER
                     = 'O':      The lower-left block is made nonpositive (the
                                 "other" convention);
                     otherwise:  The upper-right block is made nonpositive (the
                                 "default" convention).

           M

                     M is INTEGER
                     The number of rows and columns in X.

           P

                     P is INTEGER
                     The number of rows in X11 and X12. 0 <= P <= M.

           Q

                     Q is INTEGER
                     The number of columns in X11 and X21. 0 <= Q <=
                     MIN(P,M-P,M-Q).

           X11

                     X11 is COMPLEX array, dimension (LDX11,Q)
                     On entry, the top-left block of the unitary matrix to be
                     reduced. On exit, the form depends on TRANS:
                     If TRANS = 'N', then
                        the columns of tril(X11) specify reflectors for P1,
                        the rows of triu(X11,1) specify reflectors for Q1;
                     else TRANS = 'T', and
                        the rows of triu(X11) specify reflectors for P1,
                        the columns of tril(X11,-1) specify reflectors for Q1.

           LDX11

                     LDX11 is INTEGER
                     The leading dimension of X11. If TRANS = 'N', then LDX11 >=
                     P; else LDX11 >= Q.

           X12

                     X12 is COMPLEX array, dimension (LDX12,M-Q)
                     On entry, the top-right block of the unitary matrix to
                     be reduced. On exit, the form depends on TRANS:
                     If TRANS = 'N', then
                        the rows of triu(X12) specify the first P reflectors for
                        Q2;
                     else TRANS = 'T', and
                        the columns of tril(X12) specify the first P reflectors
                        for Q2.

           LDX12

                     LDX12 is INTEGER
                     The leading dimension of X12. If TRANS = 'N', then LDX12 >=
                     P; else LDX11 >= M-Q.

           X21

                     X21 is COMPLEX array, dimension (LDX21,Q)
                     On entry, the bottom-left block of the unitary matrix to
                     be reduced. On exit, the form depends on TRANS:
                     If TRANS = 'N', then
                        the columns of tril(X21) specify reflectors for P2;
                     else TRANS = 'T', and
                        the rows of triu(X21) specify reflectors for P2.

           LDX21

                     LDX21 is INTEGER
                     The leading dimension of X21. If TRANS = 'N', then LDX21 >=
                     M-P; else LDX21 >= Q.

           X22

                     X22 is COMPLEX array, dimension (LDX22,M-Q)
                     On entry, the bottom-right block of the unitary matrix to
                     be reduced. On exit, the form depends on TRANS:
                     If TRANS = 'N', then
                        the rows of triu(X22(Q+1:M-P,P+1:M-Q)) specify the last
                        M-P-Q reflectors for Q2,
                     else TRANS = 'T', and
                        the columns of tril(X22(P+1:M-Q,Q+1:M-P)) specify the last
                        M-P-Q reflectors for P2.

           LDX22

                     LDX22 is INTEGER
                     The leading dimension of X22. If TRANS = 'N', then LDX22 >=
                     M-P; else LDX22 >= M-Q.

           THETA

                     THETA is REAL array, dimension (Q)
                     The entries of the bidiagonal blocks B11, B12, B21, B22 can
                     be computed from the angles THETA and PHI. See Further
                     Details.

           PHI

                     PHI is REAL array, dimension (Q-1)
                     The entries of the bidiagonal blocks B11, B12, B21, B22 can
                     be computed from the angles THETA and PHI. See Further
                     Details.

           TAUP1

                     TAUP1 is COMPLEX array, dimension (P)
                     The scalar factors of the elementary reflectors that define
                     P1.

           TAUP2

                     TAUP2 is COMPLEX array, dimension (M-P)
                     The scalar factors of the elementary reflectors that define
                     P2.

           TAUQ1

                     TAUQ1 is COMPLEX array, dimension (Q)
                     The scalar factors of the elementary reflectors that define
                     Q1.

           TAUQ2

                     TAUQ2 is COMPLEX array, dimension (M-Q)
                     The scalar factors of the elementary reflectors that define
                     Q2.

           WORK

                     WORK is COMPLEX array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK >= M-Q.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The bidiagonal blocks B11, B12, B21, and B22 are represented
             implicitly by angles THETA(1), ..., THETA(Q) and PHI(1), ...,
             PHI(Q-1). B11 and B21 are upper bidiagonal, while B21 and B22 are
             lower bidiagonal. Every entry in each bidiagonal band is a product
             of a sine or cosine of a THETA with a sine or cosine of a PHI. See
             [1] or CUNCSD for details.

             P1, P2, Q1, and Q2 are represented as products of elementary
             reflectors. See CUNCSD for details on generating P1, P2, Q1, and Q2
             using CUNGQR and CUNGLQ.

       References:
           [1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms,
           50(1):33-65, 2009.

   subroutine cunbdb1 (integer M, integer P, integer Q, complex, dimension(ldx11,*) X11, integer
       LDX11, complex, dimension(ldx21,*) X21, integer LDX21, real, dimension(*) THETA, real,
       dimension(*) PHI, complex, dimension(*) TAUP1, complex, dimension(*) TAUP2, complex,
       dimension(*) TAUQ1, complex, dimension(*) WORK, integer LWORK, integer INFO)
       CUNBDB1

       Purpose:

            CUNBDB1 simultaneously bidiagonalizes the blocks of a tall and skinny
            matrix X with orthonomal columns:

                                       [ B11 ]
                 [ X11 ]   [ P1 |    ] [  0  ]
                 [-----] = [---------] [-----] Q1**T .
                 [ X21 ]   [    | P2 ] [ B21 ]
                                       [  0  ]

            X11 is P-by-Q, and X21 is (M-P)-by-Q. Q must be no larger than P,
            M-P, or M-Q. Routines CUNBDB2, CUNBDB3, and CUNBDB4 handle cases in
            which Q is not the minimum dimension.

            The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P),
            and (M-Q)-by-(M-Q), respectively. They are represented implicitly by
            Householder vectors.

            B11 and B12 are Q-by-Q bidiagonal matrices represented implicitly by
            angles THETA, PHI.

       Parameters
           M

                     M is INTEGER
                      The number of rows X11 plus the number of rows in X21.

           P

                     P is INTEGER
                      The number of rows in X11. 0 <= P <= M.

           Q

                     Q is INTEGER
                      The number of columns in X11 and X21. 0 <= Q <=
                      MIN(P,M-P,M-Q).

           X11

                     X11 is COMPLEX array, dimension (LDX11,Q)
                      On entry, the top block of the matrix X to be reduced. On
                      exit, the columns of tril(X11) specify reflectors for P1 and
                      the rows of triu(X11,1) specify reflectors for Q1.

           LDX11

                     LDX11 is INTEGER
                      The leading dimension of X11. LDX11 >= P.

           X21

                     X21 is COMPLEX array, dimension (LDX21,Q)
                      On entry, the bottom block of the matrix X to be reduced. On
                      exit, the columns of tril(X21) specify reflectors for P2.

           LDX21

                     LDX21 is INTEGER
                      The leading dimension of X21. LDX21 >= M-P.

           THETA

                     THETA is REAL array, dimension (Q)
                      The entries of the bidiagonal blocks B11, B21 are defined by
                      THETA and PHI. See Further Details.

           PHI

                     PHI is REAL array, dimension (Q-1)
                      The entries of the bidiagonal blocks B11, B21 are defined by
                      THETA and PHI. See Further Details.

           TAUP1

                     TAUP1 is COMPLEX array, dimension (P)
                      The scalar factors of the elementary reflectors that define
                      P1.

           TAUP2

                     TAUP2 is COMPLEX array, dimension (M-P)
                      The scalar factors of the elementary reflectors that define
                      P2.

           TAUQ1

                     TAUQ1 is COMPLEX array, dimension (Q)
                      The scalar factors of the elementary reflectors that define
                      Q1.

           WORK

                     WORK is COMPLEX array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                      The dimension of the array WORK. LWORK >= M-Q.

                      If LWORK = -1, then a workspace query is assumed; the routine
                      only calculates the optimal size of the WORK array, returns
                      this value as the first entry of the WORK array, and no error
                      message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                      = 0:  successful exit.
                      < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The upper-bidiagonal blocks B11, B21 are represented implicitly by
             angles THETA(1), ..., THETA(Q) and PHI(1), ..., PHI(Q-1). Every entry
             in each bidiagonal band is a product of a sine or cosine of a THETA
             with a sine or cosine of a PHI. See [1] or CUNCSD for details.

             P1, P2, and Q1 are represented as products of elementary reflectors.
             See CUNCSD2BY1 for details on generating P1, P2, and Q1 using CUNGQR
             and CUNGLQ.

       References:
           [1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms,
           50(1):33-65, 2009.

   subroutine cunbdb2 (integer M, integer P, integer Q, complex, dimension(ldx11,*) X11, integer
       LDX11, complex, dimension(ldx21,*) X21, integer LDX21, real, dimension(*) THETA, real,
       dimension(*) PHI, complex, dimension(*) TAUP1, complex, dimension(*) TAUP2, complex,
       dimension(*) TAUQ1, complex, dimension(*) WORK, integer LWORK, integer INFO)
       CUNBDB2

       Purpose:

            CUNBDB2 simultaneously bidiagonalizes the blocks of a tall and skinny
            matrix X with orthonomal columns:

                                       [ B11 ]
                 [ X11 ]   [ P1 |    ] [  0  ]
                 [-----] = [---------] [-----] Q1**T .
                 [ X21 ]   [    | P2 ] [ B21 ]
                                       [  0  ]

            X11 is P-by-Q, and X21 is (M-P)-by-Q. P must be no larger than M-P,
            Q, or M-Q. Routines CUNBDB1, CUNBDB3, and CUNBDB4 handle cases in
            which P is not the minimum dimension.

            The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P),
            and (M-Q)-by-(M-Q), respectively. They are represented implicitly by
            Householder vectors.

            B11 and B12 are P-by-P bidiagonal matrices represented implicitly by
            angles THETA, PHI.

       Parameters
           M

                     M is INTEGER
                      The number of rows X11 plus the number of rows in X21.

           P

                     P is INTEGER
                      The number of rows in X11. 0 <= P <= min(M-P,Q,M-Q).

           Q

                     Q is INTEGER
                      The number of columns in X11 and X21. 0 <= Q <= M.

           X11

                     X11 is COMPLEX array, dimension (LDX11,Q)
                      On entry, the top block of the matrix X to be reduced. On
                      exit, the columns of tril(X11) specify reflectors for P1 and
                      the rows of triu(X11,1) specify reflectors for Q1.

           LDX11

                     LDX11 is INTEGER
                      The leading dimension of X11. LDX11 >= P.

           X21

                     X21 is COMPLEX array, dimension (LDX21,Q)
                      On entry, the bottom block of the matrix X to be reduced. On
                      exit, the columns of tril(X21) specify reflectors for P2.

           LDX21

                     LDX21 is INTEGER
                      The leading dimension of X21. LDX21 >= M-P.

           THETA

                     THETA is REAL array, dimension (Q)
                      The entries of the bidiagonal blocks B11, B21 are defined by
                      THETA and PHI. See Further Details.

           PHI

                     PHI is REAL array, dimension (Q-1)
                      The entries of the bidiagonal blocks B11, B21 are defined by
                      THETA and PHI. See Further Details.

           TAUP1

                     TAUP1 is COMPLEX array, dimension (P)
                      The scalar factors of the elementary reflectors that define
                      P1.

           TAUP2

                     TAUP2 is COMPLEX array, dimension (M-P)
                      The scalar factors of the elementary reflectors that define
                      P2.

           TAUQ1

                     TAUQ1 is COMPLEX array, dimension (Q)
                      The scalar factors of the elementary reflectors that define
                      Q1.

           WORK

                     WORK is COMPLEX array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                      The dimension of the array WORK. LWORK >= M-Q.

                      If LWORK = -1, then a workspace query is assumed; the routine
                      only calculates the optimal size of the WORK array, returns
                      this value as the first entry of the WORK array, and no error
                      message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                      = 0:  successful exit.
                      < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The upper-bidiagonal blocks B11, B21 are represented implicitly by
             angles THETA(1), ..., THETA(Q) and PHI(1), ..., PHI(Q-1). Every entry
             in each bidiagonal band is a product of a sine or cosine of a THETA
             with a sine or cosine of a PHI. See [1] or CUNCSD for details.

             P1, P2, and Q1 are represented as products of elementary reflectors.
             See CUNCSD2BY1 for details on generating P1, P2, and Q1 using CUNGQR
             and CUNGLQ.

       References:
           [1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms,
           50(1):33-65, 2009.

   subroutine cunbdb3 (integer M, integer P, integer Q, complex, dimension(ldx11,*) X11, integer
       LDX11, complex, dimension(ldx21,*) X21, integer LDX21, real, dimension(*) THETA, real,
       dimension(*) PHI, complex, dimension(*) TAUP1, complex, dimension(*) TAUP2, complex,
       dimension(*) TAUQ1, complex, dimension(*) WORK, integer LWORK, integer INFO)
       CUNBDB3

       Purpose:

            CUNBDB3 simultaneously bidiagonalizes the blocks of a tall and skinny
            matrix X with orthonomal columns:

                                       [ B11 ]
                 [ X11 ]   [ P1 |    ] [  0  ]
                 [-----] = [---------] [-----] Q1**T .
                 [ X21 ]   [    | P2 ] [ B21 ]
                                       [  0  ]

            X11 is P-by-Q, and X21 is (M-P)-by-Q. M-P must be no larger than P,
            Q, or M-Q. Routines CUNBDB1, CUNBDB2, and CUNBDB4 handle cases in
            which M-P is not the minimum dimension.

            The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P),
            and (M-Q)-by-(M-Q), respectively. They are represented implicitly by
            Householder vectors.

            B11 and B12 are (M-P)-by-(M-P) bidiagonal matrices represented
            implicitly by angles THETA, PHI.

       Parameters
           M

                     M is INTEGER
                      The number of rows X11 plus the number of rows in X21.

           P

                     P is INTEGER
                      The number of rows in X11. 0 <= P <= M. M-P <= min(P,Q,M-Q).

           Q

                     Q is INTEGER
                      The number of columns in X11 and X21. 0 <= Q <= M.

           X11

                     X11 is COMPLEX array, dimension (LDX11,Q)
                      On entry, the top block of the matrix X to be reduced. On
                      exit, the columns of tril(X11) specify reflectors for P1 and
                      the rows of triu(X11,1) specify reflectors for Q1.

           LDX11

                     LDX11 is INTEGER
                      The leading dimension of X11. LDX11 >= P.

           X21

                     X21 is COMPLEX array, dimension (LDX21,Q)
                      On entry, the bottom block of the matrix X to be reduced. On
                      exit, the columns of tril(X21) specify reflectors for P2.

           LDX21

                     LDX21 is INTEGER
                      The leading dimension of X21. LDX21 >= M-P.

           THETA

                     THETA is REAL array, dimension (Q)
                      The entries of the bidiagonal blocks B11, B21 are defined by
                      THETA and PHI. See Further Details.

           PHI

                     PHI is REAL array, dimension (Q-1)
                      The entries of the bidiagonal blocks B11, B21 are defined by
                      THETA and PHI. See Further Details.

           TAUP1

                     TAUP1 is COMPLEX array, dimension (P)
                      The scalar factors of the elementary reflectors that define
                      P1.

           TAUP2

                     TAUP2 is COMPLEX array, dimension (M-P)
                      The scalar factors of the elementary reflectors that define
                      P2.

           TAUQ1

                     TAUQ1 is COMPLEX array, dimension (Q)
                      The scalar factors of the elementary reflectors that define
                      Q1.

           WORK

                     WORK is COMPLEX array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                      The dimension of the array WORK. LWORK >= M-Q.

                      If LWORK = -1, then a workspace query is assumed; the routine
                      only calculates the optimal size of the WORK array, returns
                      this value as the first entry of the WORK array, and no error
                      message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                      = 0:  successful exit.
                      < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The upper-bidiagonal blocks B11, B21 are represented implicitly by
             angles THETA(1), ..., THETA(Q) and PHI(1), ..., PHI(Q-1). Every entry
             in each bidiagonal band is a product of a sine or cosine of a THETA
             with a sine or cosine of a PHI. See [1] or CUNCSD for details.

             P1, P2, and Q1 are represented as products of elementary reflectors.
             See CUNCSD2BY1 for details on generating P1, P2, and Q1 using CUNGQR
             and CUNGLQ.

       References:
           [1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms,
           50(1):33-65, 2009.

   subroutine cunbdb4 (integer M, integer P, integer Q, complex, dimension(ldx11,*) X11, integer
       LDX11, complex, dimension(ldx21,*) X21, integer LDX21, real, dimension(*) THETA, real,
       dimension(*) PHI, complex, dimension(*) TAUP1, complex, dimension(*) TAUP2, complex,
       dimension(*) TAUQ1, complex, dimension(*) PHANTOM, complex, dimension(*) WORK, integer
       LWORK, integer INFO)
       CUNBDB4

       Purpose:

            CUNBDB4 simultaneously bidiagonalizes the blocks of a tall and skinny
            matrix X with orthonomal columns:

                                       [ B11 ]
                 [ X11 ]   [ P1 |    ] [  0  ]
                 [-----] = [---------] [-----] Q1**T .
                 [ X21 ]   [    | P2 ] [ B21 ]
                                       [  0  ]

            X11 is P-by-Q, and X21 is (M-P)-by-Q. M-Q must be no larger than P,
            M-P, or Q. Routines CUNBDB1, CUNBDB2, and CUNBDB3 handle cases in
            which M-Q is not the minimum dimension.

            The unitary matrices P1, P2, and Q1 are P-by-P, (M-P)-by-(M-P),
            and (M-Q)-by-(M-Q), respectively. They are represented implicitly by
            Householder vectors.

            B11 and B12 are (M-Q)-by-(M-Q) bidiagonal matrices represented
            implicitly by angles THETA, PHI.

       Parameters
           M

                     M is INTEGER
                      The number of rows X11 plus the number of rows in X21.

           P

                     P is INTEGER
                      The number of rows in X11. 0 <= P <= M.

           Q

                     Q is INTEGER
                      The number of columns in X11 and X21. 0 <= Q <= M and
                      M-Q <= min(P,M-P,Q).

           X11

                     X11 is COMPLEX array, dimension (LDX11,Q)
                      On entry, the top block of the matrix X to be reduced. On
                      exit, the columns of tril(X11) specify reflectors for P1 and
                      the rows of triu(X11,1) specify reflectors for Q1.

           LDX11

                     LDX11 is INTEGER
                      The leading dimension of X11. LDX11 >= P.

           X21

                     X21 is COMPLEX array, dimension (LDX21,Q)
                      On entry, the bottom block of the matrix X to be reduced. On
                      exit, the columns of tril(X21) specify reflectors for P2.

           LDX21

                     LDX21 is INTEGER
                      The leading dimension of X21. LDX21 >= M-P.

           THETA

                     THETA is REAL array, dimension (Q)
                      The entries of the bidiagonal blocks B11, B21 are defined by
                      THETA and PHI. See Further Details.

           PHI

                     PHI is REAL array, dimension (Q-1)
                      The entries of the bidiagonal blocks B11, B21 are defined by
                      THETA and PHI. See Further Details.

           TAUP1

                     TAUP1 is COMPLEX array, dimension (P)
                      The scalar factors of the elementary reflectors that define
                      P1.

           TAUP2

                     TAUP2 is COMPLEX array, dimension (M-P)
                      The scalar factors of the elementary reflectors that define
                      P2.

           TAUQ1

                     TAUQ1 is COMPLEX array, dimension (Q)
                      The scalar factors of the elementary reflectors that define
                      Q1.

           PHANTOM

                     PHANTOM is COMPLEX array, dimension (M)
                      The routine computes an M-by-1 column vector Y that is
                      orthogonal to the columns of [ X11; X21 ]. PHANTOM(1:P) and
                      PHANTOM(P+1:M) contain Householder vectors for Y(1:P) and
                      Y(P+1:M), respectively.

           WORK

                     WORK is COMPLEX array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                      The dimension of the array WORK. LWORK >= M-Q.

                      If LWORK = -1, then a workspace query is assumed; the routine
                      only calculates the optimal size of the WORK array, returns
                      this value as the first entry of the WORK array, and no error
                      message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                      = 0:  successful exit.
                      < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Further Details:

             The upper-bidiagonal blocks B11, B21 are represented implicitly by
             angles THETA(1), ..., THETA(Q) and PHI(1), ..., PHI(Q-1). Every entry
             in each bidiagonal band is a product of a sine or cosine of a THETA
             with a sine or cosine of a PHI. See [1] or CUNCSD for details.

             P1, P2, and Q1 are represented as products of elementary reflectors.
             See CUNCSD2BY1 for details on generating P1, P2, and Q1 using CUNGQR
             and CUNGLQ.

       References:
           [1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms,
           50(1):33-65, 2009.

   subroutine cunbdb5 (integer M1, integer M2, integer N, complex, dimension(*) X1, integer
       INCX1, complex, dimension(*) X2, integer INCX2, complex, dimension(ldq1,*) Q1, integer
       LDQ1, complex, dimension(ldq2,*) Q2, integer LDQ2, complex, dimension(*) WORK, integer
       LWORK, integer INFO)
       CUNBDB5

       Purpose:

            CUNBDB5 orthogonalizes the column vector
                 X = [ X1 ]
                     [ X2 ]
            with respect to the columns of
                 Q = [ Q1 ] .
                     [ Q2 ]
            The columns of Q must be orthonormal.

            If the projection is zero according to Kahan's "twice is enough"
            criterion, then some other vector from the orthogonal complement
            is returned. This vector is chosen in an arbitrary but deterministic
            way.

       Parameters
           M1

                     M1 is INTEGER
                      The dimension of X1 and the number of rows in Q1. 0 <= M1.

           M2

                     M2 is INTEGER
                      The dimension of X2 and the number of rows in Q2. 0 <= M2.

           N

                     N is INTEGER
                      The number of columns in Q1 and Q2. 0 <= N.

           X1

                     X1 is COMPLEX array, dimension (M1)
                      On entry, the top part of the vector to be orthogonalized.
                      On exit, the top part of the projected vector.

           INCX1

                     INCX1 is INTEGER
                      Increment for entries of X1.

           X2

                     X2 is COMPLEX array, dimension (M2)
                      On entry, the bottom part of the vector to be
                      orthogonalized. On exit, the bottom part of the projected
                      vector.

           INCX2

                     INCX2 is INTEGER
                      Increment for entries of X2.

           Q1

                     Q1 is COMPLEX array, dimension (LDQ1, N)
                      The top part of the orthonormal basis matrix.

           LDQ1

                     LDQ1 is INTEGER
                      The leading dimension of Q1. LDQ1 >= M1.

           Q2

                     Q2 is COMPLEX array, dimension (LDQ2, N)
                      The bottom part of the orthonormal basis matrix.

           LDQ2

                     LDQ2 is INTEGER
                      The leading dimension of Q2. LDQ2 >= M2.

           WORK

                     WORK is COMPLEX array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                      The dimension of the array WORK. LWORK >= N.

           INFO

                     INFO is INTEGER
                      = 0:  successful exit.
                      < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunbdb6 (integer M1, integer M2, integer N, complex, dimension(*) X1, integer
       INCX1, complex, dimension(*) X2, integer INCX2, complex, dimension(ldq1,*) Q1, integer
       LDQ1, complex, dimension(ldq2,*) Q2, integer LDQ2, complex, dimension(*) WORK, integer
       LWORK, integer INFO)
       CUNBDB6

       Purpose:

            CUNBDB6 orthogonalizes the column vector
                 X = [ X1 ]
                     [ X2 ]
            with respect to the columns of
                 Q = [ Q1 ] .
                     [ Q2 ]
            The columns of Q must be orthonormal.

            If the projection is zero according to Kahan's "twice is enough"
            criterion, then the zero vector is returned.

       Parameters
           M1

                     M1 is INTEGER
                      The dimension of X1 and the number of rows in Q1. 0 <= M1.

           M2

                     M2 is INTEGER
                      The dimension of X2 and the number of rows in Q2. 0 <= M2.

           N

                     N is INTEGER
                      The number of columns in Q1 and Q2. 0 <= N.

           X1

                     X1 is COMPLEX array, dimension (M1)
                      On entry, the top part of the vector to be orthogonalized.
                      On exit, the top part of the projected vector.

           INCX1

                     INCX1 is INTEGER
                      Increment for entries of X1.

           X2

                     X2 is COMPLEX array, dimension (M2)
                      On entry, the bottom part of the vector to be
                      orthogonalized. On exit, the bottom part of the projected
                      vector.

           INCX2

                     INCX2 is INTEGER
                      Increment for entries of X2.

           Q1

                     Q1 is COMPLEX array, dimension (LDQ1, N)
                      The top part of the orthonormal basis matrix.

           LDQ1

                     LDQ1 is INTEGER
                      The leading dimension of Q1. LDQ1 >= M1.

           Q2

                     Q2 is COMPLEX array, dimension (LDQ2, N)
                      The bottom part of the orthonormal basis matrix.

           LDQ2

                     LDQ2 is INTEGER
                      The leading dimension of Q2. LDQ2 >= M2.

           WORK

                     WORK is COMPLEX array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                      The dimension of the array WORK. LWORK >= N.

           INFO

                     INFO is INTEGER
                      = 0:  successful exit.
                      < 0:  if INFO = -i, the i-th argument had an illegal value.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   recursive subroutine cuncsd (character JOBU1, character JOBU2, character JOBV1T, character
       JOBV2T, character TRANS, character SIGNS, integer M, integer P, integer Q, complex,
       dimension( ldx11, * ) X11, integer LDX11, complex, dimension( ldx12, * ) X12, integer
       LDX12, complex, dimension( ldx21, * ) X21, integer LDX21, complex, dimension( ldx22,
       * ) X22, integer LDX22, real, dimension( * ) THETA, complex, dimension( ldu1, * ) U1,
       integer LDU1, complex, dimension( ldu2, * ) U2, integer LDU2, complex, dimension( ldv1t, *
       ) V1T, integer LDV1T, complex, dimension( ldv2t, * ) V2T, integer LDV2T, complex,
       dimension( * ) WORK, integer LWORK, real, dimension( * ) RWORK, integer LRWORK, integer,
       dimension( * ) IWORK, integer INFO)
       CUNCSD

       Purpose:

            CUNCSD computes the CS decomposition of an M-by-M partitioned
            unitary matrix X:

                                            [  I  0  0 |  0  0  0 ]
                                            [  0  C  0 |  0 -S  0 ]
                [ X11 | X12 ]   [ U1 |    ] [  0  0  0 |  0  0 -I ] [ V1 |    ]**H
            X = [-----------] = [---------] [---------------------] [---------]   .
                [ X21 | X22 ]   [    | U2 ] [  0  0  0 |  I  0  0 ] [    | V2 ]
                                            [  0  S  0 |  0  C  0 ]
                                            [  0  0  I |  0  0  0 ]

            X11 is P-by-Q. The unitary matrices U1, U2, V1, and V2 are P-by-P,
            (M-P)-by-(M-P), Q-by-Q, and (M-Q)-by-(M-Q), respectively. C and S are
            R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in
            which R = MIN(P,M-P,Q,M-Q).

       Parameters
           JOBU1

                     JOBU1 is CHARACTER
                     = 'Y':      U1 is computed;
                     otherwise:  U1 is not computed.

           JOBU2

                     JOBU2 is CHARACTER
                     = 'Y':      U2 is computed;
                     otherwise:  U2 is not computed.

           JOBV1T

                     JOBV1T is CHARACTER
                     = 'Y':      V1T is computed;
                     otherwise:  V1T is not computed.

           JOBV2T

                     JOBV2T is CHARACTER
                     = 'Y':      V2T is computed;
                     otherwise:  V2T is not computed.

           TRANS

                     TRANS is CHARACTER
                     = 'T':      X, U1, U2, V1T, and V2T are stored in row-major
                                 order;
                     otherwise:  X, U1, U2, V1T, and V2T are stored in column-
                                 major order.

           SIGNS

                     SIGNS is CHARACTER
                     = 'O':      The lower-left block is made nonpositive (the
                                 "other" convention);
                     otherwise:  The upper-right block is made nonpositive (the
                                 "default" convention).

           M

                     M is INTEGER
                     The number of rows and columns in X.

           P

                     P is INTEGER
                     The number of rows in X11 and X12. 0 <= P <= M.

           Q

                     Q is INTEGER
                     The number of columns in X11 and X21. 0 <= Q <= M.

           X11

                     X11 is COMPLEX array, dimension (LDX11,Q)
                     On entry, part of the unitary matrix whose CSD is desired.

           LDX11

                     LDX11 is INTEGER
                     The leading dimension of X11. LDX11 >= MAX(1,P).

           X12

                     X12 is COMPLEX array, dimension (LDX12,M-Q)
                     On entry, part of the unitary matrix whose CSD is desired.

           LDX12

                     LDX12 is INTEGER
                     The leading dimension of X12. LDX12 >= MAX(1,P).

           X21

                     X21 is COMPLEX array, dimension (LDX21,Q)
                     On entry, part of the unitary matrix whose CSD is desired.

           LDX21

                     LDX21 is INTEGER
                     The leading dimension of X11. LDX21 >= MAX(1,M-P).

           X22

                     X22 is COMPLEX array, dimension (LDX22,M-Q)
                     On entry, part of the unitary matrix whose CSD is desired.

           LDX22

                     LDX22 is INTEGER
                     The leading dimension of X11. LDX22 >= MAX(1,M-P).

           THETA

                     THETA is REAL array, dimension (R), in which R =
                     MIN(P,M-P,Q,M-Q).
                     C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and
                     S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) ).

           U1

                     U1 is COMPLEX array, dimension (LDU1,P)
                     If JOBU1 = 'Y', U1 contains the P-by-P unitary matrix U1.

           LDU1

                     LDU1 is INTEGER
                     The leading dimension of U1. If JOBU1 = 'Y', LDU1 >=
                     MAX(1,P).

           U2

                     U2 is COMPLEX array, dimension (LDU2,M-P)
                     If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) unitary
                     matrix U2.

           LDU2

                     LDU2 is INTEGER
                     The leading dimension of U2. If JOBU2 = 'Y', LDU2 >=
                     MAX(1,M-P).

           V1T

                     V1T is COMPLEX array, dimension (LDV1T,Q)
                     If JOBV1T = 'Y', V1T contains the Q-by-Q matrix unitary
                     matrix V1**H.

           LDV1T

                     LDV1T is INTEGER
                     The leading dimension of V1T. If JOBV1T = 'Y', LDV1T >=
                     MAX(1,Q).

           V2T

                     V2T is COMPLEX array, dimension (LDV2T,M-Q)
                     If JOBV2T = 'Y', V2T contains the (M-Q)-by-(M-Q) unitary
                     matrix V2**H.

           LDV2T

                     LDV2T is INTEGER
                     The leading dimension of V2T. If JOBV2T = 'Y', LDV2T >=
                     MAX(1,M-Q).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the work array, and no error
                     message related to LWORK is issued by XERBLA.

           RWORK

                     RWORK is REAL array, dimension MAX(1,LRWORK)
                     On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.
                     If INFO > 0 on exit, RWORK(2:R) contains the values PHI(1),
                     ..., PHI(R-1) that, together with THETA(1), ..., THETA(R),
                     define the matrix in intermediate bidiagonal-block form
                     remaining after nonconvergence. INFO specifies the number
                     of nonzero PHI's.

           LRWORK

                     LRWORK is INTEGER
                     The dimension of the array RWORK.

                     If LRWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the RWORK array, returns
                     this value as the first entry of the work array, and no error
                     message related to LRWORK is issued by XERBLA.

           IWORK

                     IWORK is INTEGER array, dimension (M-MIN(P,M-P,Q,M-Q))

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  CBBCSD did not converge. See the description of RWORK
                           above for details.

       References:
           [1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms,
           50(1):33-65, 2009.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cuncsd2by1 (character JOBU1, character JOBU2, character JOBV1T, integer M, integer
       P, integer Q, complex, dimension(ldx11,*) X11, integer LDX11, complex, dimension(ldx21,*)
       X21, integer LDX21, real, dimension(*) THETA, complex, dimension(ldu1,*) U1, integer LDU1,
       complex, dimension(ldu2,*) U2, integer LDU2, complex, dimension(ldv1t,*) V1T, integer
       LDV1T, complex, dimension(*) WORK, integer LWORK, real, dimension(*) RWORK, integer
       LRWORK, integer, dimension(*) IWORK, integer INFO)
       CUNCSD2BY1

       Purpose:

            CUNCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with
            orthonormal columns that has been partitioned into a 2-by-1 block
            structure:

                                           [  I1 0  0 ]
                                           [  0  C  0 ]
                     [ X11 ]   [ U1 |    ] [  0  0  0 ]
                 X = [-----] = [---------] [----------] V1**T .
                     [ X21 ]   [    | U2 ] [  0  0  0 ]
                                           [  0  S  0 ]
                                           [  0  0  I2]

            X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P,
            (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R
            nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which
            R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a
            K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).

       Parameters
           JOBU1

                     JOBU1 is CHARACTER
                     = 'Y':      U1 is computed;
                     otherwise:  U1 is not computed.

           JOBU2

                     JOBU2 is CHARACTER
                     = 'Y':      U2 is computed;
                     otherwise:  U2 is not computed.

           JOBV1T

                     JOBV1T is CHARACTER
                     = 'Y':      V1T is computed;
                     otherwise:  V1T is not computed.

           M

                     M is INTEGER
                     The number of rows in X.

           P

                     P is INTEGER
                     The number of rows in X11. 0 <= P <= M.

           Q

                     Q is INTEGER
                     The number of columns in X11 and X21. 0 <= Q <= M.

           X11

                     X11 is COMPLEX array, dimension (LDX11,Q)
                     On entry, part of the unitary matrix whose CSD is desired.

           LDX11

                     LDX11 is INTEGER
                     The leading dimension of X11. LDX11 >= MAX(1,P).

           X21

                     X21 is COMPLEX array, dimension (LDX21,Q)
                     On entry, part of the unitary matrix whose CSD is desired.

           LDX21

                     LDX21 is INTEGER
                     The leading dimension of X21. LDX21 >= MAX(1,M-P).

           THETA

                     THETA is REAL array, dimension (R), in which R =
                     MIN(P,M-P,Q,M-Q).
                     C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and
                     S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) ).

           U1

                     U1 is COMPLEX array, dimension (P)
                     If JOBU1 = 'Y', U1 contains the P-by-P unitary matrix U1.

           LDU1

                     LDU1 is INTEGER
                     The leading dimension of U1. If JOBU1 = 'Y', LDU1 >=
                     MAX(1,P).

           U2

                     U2 is COMPLEX array, dimension (M-P)
                     If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) unitary
                     matrix U2.

           LDU2

                     LDU2 is INTEGER
                     The leading dimension of U2. If JOBU2 = 'Y', LDU2 >=
                     MAX(1,M-P).

           V1T

                     V1T is COMPLEX array, dimension (Q)
                     If JOBV1T = 'Y', V1T contains the Q-by-Q matrix unitary
                     matrix V1**T.

           LDV1T

                     LDV1T is INTEGER
                     The leading dimension of V1T. If JOBV1T = 'Y', LDV1T >=
                     MAX(1,Q).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK and RWORK
                     arrays, returns this value as the first entry of the WORK
                     and RWORK array, respectively, and no error message related
                     to LWORK or LRWORK is issued by XERBLA.

           RWORK

                     RWORK is REAL array, dimension (MAX(1,LRWORK))
                     On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.
                     If INFO > 0 on exit, RWORK(2:R) contains the values PHI(1),
                     ..., PHI(R-1) that, together with THETA(1), ..., THETA(R),
                     define the matrix in intermediate bidiagonal-block form
                     remaining after nonconvergence. INFO specifies the number
                     of nonzero PHI's.

           LRWORK

                     LRWORK is INTEGER
                     The dimension of the array RWORK.

                     If LRWORK=-1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK and RWORK
                     arrays, returns this value as the first entry of the WORK
                     and RWORK array, respectively, and no error message related
                     to LWORK or LRWORK is issued by XERBLA.

           IWORK

                     IWORK is INTEGER array, dimension (M-MIN(P,M-P,Q,M-Q))

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  CBBCSD did not converge. See the description of WORK
                           above for details.

       References:
           [1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms,
           50(1):33-65, 2009.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cung2l (integer M, integer N, integer K, complex, dimension( lda, * ) A, integer
       LDA, complex, dimension( * ) TAU, complex, dimension( * ) WORK, integer INFO)
       CUNG2L generates all or part of the unitary matrix Q from a QL factorization determined by
       cgeqlf (unblocked algorithm).

       Purpose:

            CUNG2L generates an m by n complex matrix Q with orthonormal columns,
            which is defined as the last n columns of a product of k elementary
            reflectors of order m

                  Q  =  H(k) . . . H(2) H(1)

            as returned by CGEQLF.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix Q. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix Q. M >= N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     matrix Q. N >= K >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the (n-k+i)-th column must contain the vector which
                     defines the elementary reflector H(i), for i = 1,2,...,k, as
                     returned by CGEQLF in the last k columns of its array
                     argument A.
                     On exit, the m-by-n matrix Q.

           LDA

                     LDA is INTEGER
                     The first dimension of the array A. LDA >= max(1,M).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGEQLF.

           WORK

                     WORK is COMPLEX array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument has an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cung2r (integer M, integer N, integer K, complex, dimension( lda, * ) A, integer
       LDA, complex, dimension( * ) TAU, complex, dimension( * ) WORK, integer INFO)
       CUNG2R

       Purpose:

            CUNG2R generates an m by n complex matrix Q with orthonormal columns,
            which is defined as the first n columns of a product of k elementary
            reflectors of order m

                  Q  =  H(1) H(2) . . . H(k)

            as returned by CGEQRF.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix Q. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix Q. M >= N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     matrix Q. N >= K >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the i-th column must contain the vector which
                     defines the elementary reflector H(i), for i = 1,2,...,k, as
                     returned by CGEQRF in the first k columns of its array
                     argument A.
                     On exit, the m by n matrix Q.

           LDA

                     LDA is INTEGER
                     The first dimension of the array A. LDA >= max(1,M).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGEQRF.

           WORK

                     WORK is COMPLEX array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument has an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunghr (integer N, integer ILO, integer IHI, complex, dimension( lda, * ) A,
       integer LDA, complex, dimension( * ) TAU, complex, dimension( * ) WORK, integer LWORK,
       integer INFO)
       CUNGHR

       Purpose:

            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).

       Parameters
           N

                     N is INTEGER
                     The order of the matrix Q. N >= 0.

           ILO

                     ILO is INTEGER

           IHI

                     IHI is INTEGER

                     ILO and IHI must have the same values as in the previous call
                     of CGEHRD. Q is equal to the unit matrix except in the
                     submatrix Q(ilo+1:ihi,ilo+1:ihi).
                     1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the vectors which define the elementary reflectors,
                     as returned by CGEHRD.
                     On exit, the N-by-N unitary matrix Q.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= max(1,N).

           TAU

                     TAU is COMPLEX array, dimension (N-1)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGEHRD.

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK >= IHI-ILO.
                     For optimum performance LWORK >= (IHI-ILO)*NB, where NB is
                     the optimal blocksize.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cungl2 (integer M, integer N, integer K, complex, dimension( lda, * ) A, integer
       LDA, complex, dimension( * ) TAU, complex, dimension( * ) WORK, integer INFO)
       CUNGL2 generates all or part of the unitary matrix Q from an LQ factorization determined
       by cgelqf (unblocked algorithm).

       Purpose:

            CUNGL2 generates an m-by-n complex matrix Q with orthonormal rows,
            which is defined as the first m rows of a product of k elementary
            reflectors of order n

                  Q  =  H(k)**H . . . H(2)**H H(1)**H

            as returned by CGELQF.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix Q. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix Q. N >= M.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     matrix Q. M >= K >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the i-th row must contain the vector which defines
                     the elementary reflector H(i), for i = 1,2,...,k, as returned
                     by CGELQF in the first k rows of its array argument A.
                     On exit, the m by n matrix Q.

           LDA

                     LDA is INTEGER
                     The first dimension of the array A. LDA >= max(1,M).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGELQF.

           WORK

                     WORK is COMPLEX array, dimension (M)

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument has an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunglq (integer M, integer N, integer K, complex, dimension( lda, * ) A, integer
       LDA, complex, dimension( * ) TAU, complex, dimension( * ) WORK, integer LWORK, integer
       INFO)
       CUNGLQ

       Purpose:

            CUNGLQ generates an M-by-N complex matrix Q with orthonormal rows,
            which is defined as the first M rows of a product of K elementary
            reflectors of order N

                  Q  =  H(k)**H . . . H(2)**H H(1)**H

            as returned by CGELQF.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix Q. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix Q. N >= M.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     matrix Q. M >= K >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the i-th row must contain the vector which defines
                     the elementary reflector H(i), for i = 1,2,...,k, as returned
                     by CGELQF in the first k rows of its array argument A.
                     On exit, the M-by-N matrix Q.

           LDA

                     LDA is INTEGER
                     The first dimension of the array A. LDA >= max(1,M).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGELQF.

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK >= max(1,M).
                     For optimum performance LWORK >= M*NB, where NB is
                     the optimal blocksize.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit;
                     < 0:  if INFO = -i, the i-th argument has an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cungql (integer M, integer N, integer K, complex, dimension( lda, * ) A, integer
       LDA, complex, dimension( * ) TAU, complex, dimension( * ) WORK, integer LWORK, integer
       INFO)
       CUNGQL

       Purpose:

            CUNGQL generates an M-by-N complex matrix Q with orthonormal columns,
            which is defined as the last N columns of a product of K elementary
            reflectors of order M

                  Q  =  H(k) . . . H(2) H(1)

            as returned by CGEQLF.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix Q. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix Q. M >= N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     matrix Q. N >= K >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the (n-k+i)-th column must contain the vector which
                     defines the elementary reflector H(i), for i = 1,2,...,k, as
                     returned by CGEQLF in the last k columns of its array
                     argument A.
                     On exit, the M-by-N matrix Q.

           LDA

                     LDA is INTEGER
                     The first dimension of the array A. LDA >= max(1,M).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGEQLF.

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK >= max(1,N).
                     For optimum performance LWORK >= N*NB, where NB is the
                     optimal blocksize.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument has an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cungqr (integer M, integer N, integer K, complex, dimension( lda, * ) A, integer
       LDA, complex, dimension( * ) TAU, complex, dimension( * ) WORK, integer LWORK, integer
       INFO)
       CUNGQR

       Purpose:

            CUNGQR generates an M-by-N complex matrix Q with orthonormal columns,
            which is defined as the first N columns of a product of K elementary
            reflectors of order M

                  Q  =  H(1) H(2) . . . H(k)

            as returned by CGEQRF.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix Q. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix Q. M >= N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     matrix Q. N >= K >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the i-th column must contain the vector which
                     defines the elementary reflector H(i), for i = 1,2,...,k, as
                     returned by CGEQRF in the first k columns of its array
                     argument A.
                     On exit, the M-by-N matrix Q.

           LDA

                     LDA is INTEGER
                     The first dimension of the array A. LDA >= max(1,M).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGEQRF.

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK >= max(1,N).
                     For optimum performance LWORK >= N*NB, where NB is the
                     optimal blocksize.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument has an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cungr2 (integer M, integer N, integer K, complex, dimension( lda, * ) A, integer
       LDA, complex, dimension( * ) TAU, complex, dimension( * ) WORK, integer INFO)
       CUNGR2 generates all or part of the unitary matrix Q from an RQ factorization determined
       by cgerqf (unblocked algorithm).

       Purpose:

            CUNGR2 generates an m by n complex matrix Q with orthonormal rows,
            which is defined as the last m rows of a product of k elementary
            reflectors of order n

                  Q  =  H(1)**H H(2)**H . . . H(k)**H

            as returned by CGERQF.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix Q. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix Q. N >= M.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     matrix Q. M >= K >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the (m-k+i)-th row must contain the vector which
                     defines the elementary reflector H(i), for i = 1,2,...,k, as
                     returned by CGERQF in the last k rows of its array argument
                     A.
                     On exit, the m-by-n matrix Q.

           LDA

                     LDA is INTEGER
                     The first dimension of the array A. LDA >= max(1,M).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGERQF.

           WORK

                     WORK is COMPLEX array, dimension (M)

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument has an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cungrq (integer M, integer N, integer K, complex, dimension( lda, * ) A, integer
       LDA, complex, dimension( * ) TAU, complex, dimension( * ) WORK, integer LWORK, integer
       INFO)
       CUNGRQ

       Purpose:

            CUNGRQ generates an M-by-N complex matrix Q with orthonormal rows,
            which is defined as the last M rows of a product of K elementary
            reflectors of order N

                  Q  =  H(1)**H H(2)**H . . . H(k)**H

            as returned by CGERQF.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix Q. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix Q. N >= M.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     matrix Q. M >= K >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the (m-k+i)-th row must contain the vector which
                     defines the elementary reflector H(i), for i = 1,2,...,k, as
                     returned by CGERQF in the last k rows of its array argument
                     A.
                     On exit, the M-by-N matrix Q.

           LDA

                     LDA is INTEGER
                     The first dimension of the array A. LDA >= max(1,M).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGERQF.

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK >= max(1,M).
                     For optimum performance LWORK >= M*NB, where NB is the
                     optimal blocksize.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument has an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cungtr (character UPLO, integer N, complex, dimension( lda, * ) A, integer LDA,
       complex, dimension( * ) TAU, complex, dimension( * ) WORK, integer LWORK, integer INFO)
       CUNGTR

       Purpose:

            CUNGTR generates a complex unitary matrix Q which is defined as the
            product of n-1 elementary reflectors of order N, as returned by
            CHETRD:

            if UPLO = 'U', Q = H(n-1) . . . H(2) H(1),

            if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U': Upper triangle of A contains elementary reflectors
                            from CHETRD;
                     = 'L': Lower triangle of A contains elementary reflectors
                            from CHETRD.

           N

                     N is INTEGER
                     The order of the matrix Q. N >= 0.

           A

                     A is COMPLEX array, dimension (LDA,N)
                     On entry, the vectors which define the elementary reflectors,
                     as returned by CHETRD.
                     On exit, the N-by-N unitary matrix Q.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= N.

           TAU

                     TAU is COMPLEX array, dimension (N-1)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CHETRD.

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK. LWORK >= N-1.
                     For optimum performance LWORK >= (N-1)*NB, where NB is
                     the optimal blocksize.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cungtsqr (integer M, integer N, integer MB, integer NB, complex, dimension( lda, *
       ) A, integer LDA, complex, dimension( ldt, * ) T, integer LDT, complex, dimension( * )
       WORK, integer LWORK, integer INFO)
       CUNGTSQR

       Purpose:

            CUNGTSQR generates an M-by-N complex matrix Q_out with orthonormal
            columns, which are the first N columns of a product of comlpex unitary
            matrices of order M which are returned by CLATSQR

                 Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ).

            See the documentation for CLATSQR.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix A.  M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix A. M >= N >= 0.

           MB

                     MB is INTEGER
                     The row block size used by CLATSQR to return
                     arrays A and T. MB > N.
                     (Note that if MB > M, then M is used instead of MB
                     as the row block size).

           NB

                     NB is INTEGER
                     The column block size used by CLATSQR to return
                     arrays A and T. NB >= 1.
                     (Note that if NB > N, then N is used instead of NB
                     as the column block size).

           A

                     A is COMPLEX array, dimension (LDA,N)

                     On entry:

                        The elements on and above the diagonal are not accessed.
                        The elements below the diagonal represent the unit
                        lower-trapezoidal blocked matrix V computed by CLATSQR
                        that defines the input matrices Q_in(k) (ones on the
                        diagonal are not stored) (same format as the output A
                        below the diagonal in CLATSQR).

                     On exit:

                        The array A contains an M-by-N orthonormal matrix Q_out,
                        i.e the columns of A are orthogonal unit vectors.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,M).

           T

                     T is COMPLEX array,
                     dimension (LDT, N * NIRB)
                     where NIRB = Number_of_input_row_blocks
                                = MAX( 1, CEIL((M-N)/(MB-N)) )
                     Let NICB = Number_of_input_col_blocks
                              = CEIL(N/NB)

                     The upper-triangular block reflectors used to define the
                     input matrices Q_in(k), k=(1:NIRB*NICB). The block
                     reflectors are stored in compact form in NIRB block
                     reflector sequences. Each of NIRB block reflector sequences
                     is stored in a larger NB-by-N column block of T and consists
                     of NICB smaller NB-by-NB upper-triangular column blocks.
                     (same format as the output T in CLATSQR).

           LDT

                     LDT is INTEGER
                     The leading dimension of the array T.
                     LDT >= max(1,min(NB1,N)).

           WORK

                     (workspace) COMPLEX array, dimension (MAX(2,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     The dimension of the array WORK.  LWORK >= (M+NB)*N.
                     If LWORK = -1, then a workspace query is assumed.
                     The routine only calculates the optimal size of the WORK
                     array, returns this value as the first entry of the WORK
                     array, and no error message related to LWORK is issued
                     by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:

            November 2019, Igor Kozachenko,
                           Computer Science Division,
                           University of California, Berkeley

   subroutine cungtsqr_row (integer M, integer N, integer MB, integer NB, complex, dimension(
       lda, * ) A, integer LDA, complex, dimension( ldt, * ) T, integer LDT, complex, dimension(
       * ) WORK, integer LWORK, integer INFO)
       CUNGTSQR_ROW

       Purpose:

            CUNGTSQR_ROW generates an M-by-N complex matrix Q_out with
            orthonormal columns from the output of CLATSQR. These N orthonormal
            columns are the first N columns of a product of complex unitary
            matrices Q(k)_in of order M, which are returned by CLATSQR in
            a special format.

                 Q_out = first_N_columns_of( Q(1)_in * Q(2)_in * ... * Q(k)_in ).

            The input matrices Q(k)_in are stored in row and column blocks in A.
            See the documentation of CLATSQR for more details on the format of
            Q(k)_in, where each Q(k)_in is represented by block Householder
            transformations. This routine calls an auxiliary routine CLARFB_GETT,
            where the computation is performed on each individual block. The
            algorithm first sweeps NB-sized column blocks from the right to left
            starting in the bottom row block and continues to the top row block
            (hence _ROW in the routine name). This sweep is in reverse order of
            the order in which CLATSQR generates the output blocks.

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix A.  M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix A. M >= N >= 0.

           MB

                     MB is INTEGER
                     The row block size used by CLATSQR to return
                     arrays A and T. MB > N.
                     (Note that if MB > M, then M is used instead of MB
                     as the row block size).

           NB

                     NB is INTEGER
                     The column block size used by CLATSQR to return
                     arrays A and T. NB >= 1.
                     (Note that if NB > N, then N is used instead of NB
                     as the column block size).

           A

                     A is COMPLEX array, dimension (LDA,N)

                     On entry:

                        The elements on and above the diagonal are not used as
                        input. The elements below the diagonal represent the unit
                        lower-trapezoidal blocked matrix V computed by CLATSQR
                        that defines the input matrices Q_in(k) (ones on the
                        diagonal are not stored). See CLATSQR for more details.

                     On exit:

                        The array A contains an M-by-N orthonormal matrix Q_out,
                        i.e the columns of A are orthogonal unit vectors.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,M).

           T

                     T is COMPLEX array,
                     dimension (LDT, N * NIRB)
                     where NIRB = Number_of_input_row_blocks
                                = MAX( 1, CEIL((M-N)/(MB-N)) )
                     Let NICB = Number_of_input_col_blocks
                              = CEIL(N/NB)

                     The upper-triangular block reflectors used to define the
                     input matrices Q_in(k), k=(1:NIRB*NICB). The block
                     reflectors are stored in compact form in NIRB block
                     reflector sequences. Each of the NIRB block reflector
                     sequences is stored in a larger NB-by-N column block of T
                     and consists of NICB smaller NB-by-NB upper-triangular
                     column blocks. See CLATSQR for more details on the format
                     of T.

           LDT

                     LDT is INTEGER
                     The leading dimension of the array T.
                     LDT >= max(1,min(NB,N)).

           WORK

                     (workspace) COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     The dimension of the array WORK.
                     LWORK >= NBLOCAL * MAX(NBLOCAL,(N-NBLOCAL)),
                     where NBLOCAL=MIN(NB,N).
                     If LWORK = -1, then a workspace query is assumed.
                     The routine only calculates the optimal size of the WORK
                     array, returns this value as the first entry of the WORK
                     array, and no error message related to LWORK is issued
                     by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:

            November 2020, Igor Kozachenko,
                           Computer Science Division,
                           University of California, Berkeley

   subroutine cunhr_col (integer M, integer N, integer NB, complex, dimension( lda, * ) A,
       integer LDA, complex, dimension( ldt, * ) T, integer LDT, complex, dimension( * ) D,
       integer INFO)
       CUNHR_COL

       Purpose:

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

       Parameters
           M

                     M is INTEGER
                     The number of rows of the matrix A. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix A. M >= N >= 0.

           NB

                     NB is INTEGER
                     The column block size to be used in the reconstruction
                     of Householder column vector blocks in the array A and
                     corresponding block reflectors in the array T. NB >= 1.
                     (Note that if NB > N, then N is used instead of NB
                     as the column block size.)

           A

                     A is COMPLEX array, dimension (LDA,N)

                     On entry:

                        The array A contains an M-by-N orthonormal matrix Q_in,
                        i.e the columns of A are orthogonal unit vectors.

                     On exit:

                        The elements below the diagonal of A represent the unit
                        lower-trapezoidal matrix V of Householder column vectors
                        V(i). The unit diagonal entries of V are not stored
                        (same format as the output below the diagonal in A from
                        CGEQRT). The matrix T and the matrix V stored on output
                        in A implicitly define Q_out.

                        The elements above the diagonal contain the factor U
                        of the "modified" LU-decomposition:
                           Q_in - ( S ) = V * U
                                  ( 0 )
                        where 0 is a (M-N)-by-(M-N) zero matrix.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,M).

           T

                     T is COMPLEX array,
                     dimension (LDT, N)

                     Let NOCB = Number_of_output_col_blocks
                              = CEIL(N/NB)

                     On exit, T(1:NB, 1:N) contains NOCB upper-triangular
                     block reflectors used to define Q_out stored in compact
                     form as a sequence of upper-triangular NB-by-NB column
                     blocks (same format as the output T in CGEQRT).
                     The matrix T and the matrix V stored on output in A
                     implicitly define Q_out. NOTE: The lower triangles
                     below the upper-triangular blocks will be filled with
                     zeros. See Further Details.

           LDT

                     LDT is INTEGER
                     The leading dimension of the array T.
                     LDT >= max(1,min(NB,N)).

           D

                     D is COMPLEX array, dimension min(M,N).
                     The elements can be only plus or minus one.

                     D(i) is constructed as D(i) = -SIGN(Q_in_i(i,i)), where
                     1 <= i <= min(M,N), and Q_in_i is Q_in after performing
                     i-1 steps of “modified” Gaussian elimination.
                     See Further Details.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Further Details:

            The computed M-by-M unitary factor Q_out is defined implicitly as
            a product of unitary matrices Q_out(i). Each Q_out(i) is stored in
            the compact WY-representation format in the corresponding blocks of
            matrices V (stored in A) and T.

            The M-by-N unit lower-trapezoidal matrix V stored in the M-by-N
            matrix A contains the column vectors V(i) in NB-size column
            blocks VB(j). For example, VB(1) contains the columns
            V(1), V(2), ... V(NB). NOTE: The unit entries on
            the diagonal of Y are not stored in A.

            The number of column blocks is

                NOCB = Number_of_output_col_blocks = CEIL(N/NB)

            where each block is of order NB except for the last block, which
            is of order LAST_NB = N - (NOCB-1)*NB.

            For example, if M=6,  N=5 and NB=2, the matrix V is

                V = (    VB(1),   VB(2), VB(3) ) =

                  = (   1                      )
                    ( v21    1                 )
                    ( v31  v32    1            )
                    ( v41  v42  v43   1        )
                    ( v51  v52  v53  v54    1  )
                    ( v61  v62  v63  v54   v65 )

            For each of the column blocks VB(i), an upper-triangular block
            reflector TB(i) is computed. These blocks are stored as
            a sequence of upper-triangular column blocks in the NB-by-N
            matrix T. The size of each TB(i) block is NB-by-NB, except
            for the last block, whose size is LAST_NB-by-LAST_NB.

            For example, if M=6,  N=5 and NB=2, the matrix T is

                T  = (    TB(1),    TB(2), TB(3) ) =

                   = ( t11  t12  t13  t14   t15  )
                     (      t22       t24        )

            The M-by-M factor Q_out is given as a product of NOCB
            unitary M-by-M matrices Q_out(i).

                Q_out = Q_out(1) * Q_out(2) * ... * Q_out(NOCB),

            where each matrix Q_out(i) is given by the WY-representation
            using corresponding blocks from the matrices V and T:

                Q_out(i) = I - VB(i) * TB(i) * (VB(i))**T,

            where I is the identity matrix. Here is the formula with matrix
            dimensions:

             Q(i){M-by-M} = I{M-by-M} -
               VB(i){M-by-INB} * TB(i){INB-by-INB} * (VB(i))**T {INB-by-M},

            where INB = NB, except for the last block NOCB
            for which INB=LAST_NB.

            =====
            NOTE:
            =====

            If Q_in is the result of doing a QR factorization
            B = Q_in * R_in, then:

            B = (Q_out*S) * R_in = Q_out * (S * R_in) = Q_out * R_out.

            So if one wants to interpret Q_out as the result
            of the QR factorization of B, then the corresponding R_out
            should be equal to R_out = S * R_in, i.e. some rows of R_in
            should be multiplied by -1.

            For the details of the algorithm, see [1].

            [1] "Reconstructing Householder vectors from tall-skinny QR",
                G. Ballard, J. Demmel, L. Grigori, M. Jacquelin, H.D. Nguyen,
                E. Solomonik, J. Parallel Distrib. Comput.,
                vol. 85, pp. 3-31, 2015.

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:

            November   2019, Igor Kozachenko,
                       Computer Science Division,
                       University of California, Berkeley

   subroutine cunm22 (character SIDE, character TRANS, integer M, integer N, integer N1, integer
       N2, complex, dimension( ldq, * ) Q, integer LDQ, complex, dimension( ldc, * ) C, integer
       LDC, complex, dimension( * ) WORK, integer LWORK, integer INFO)
       CUNM22 multiplies a general matrix by a banded unitary matrix.

       Purpose

             CUNM22 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'.
             The unitary matrix Q processes a 2-by-2 block structure

                    [  Q11  Q12  ]
                Q = [            ]
                    [  Q21  Q22  ],

             where Q12 is an N1-by-N1 lower triangular matrix and Q21 is an
             N2-by-N2 upper triangular matrix.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left;
                     = 'R': apply Q or Q**H from the Right.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  apply Q (No transpose);
                     = 'C':  apply Q**H (Conjugate transpose).

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           N1
           N2

                     N1 is INTEGER
                     N2 is INTEGER
                     The dimension of Q12 and Q21, respectively. N1, N2 >= 0.
                     The following requirement must be satisfied:
                     N1 + N2 = M if SIDE = 'L' and N1 + N2 = N if SIDE = 'R'.

           Q

                     Q is COMPLEX array, dimension
                                         (LDQ,M) if SIDE = 'L'
                                         (LDQ,N) if SIDE = 'R'

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q.
                     LDQ >= max(1,M) if SIDE = 'L'; LDQ >= max(1,N) if SIDE = 'R'.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If SIDE = 'L', LWORK >= max(1,N);
                     if SIDE = 'R', LWORK >= max(1,M).
                     For optimum performance LWORK >= M*N.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunm2l (character SIDE, character TRANS, integer M, integer N, integer K, complex,
       dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU, complex, dimension( ldc,
       * ) C, integer LDC, complex, dimension( * ) WORK, integer INFO)
       CUNM2L multiplies a general matrix by the unitary matrix from a QL factorization
       determined by cgeqlf (unblocked algorithm).

       Purpose:

            CUNM2L 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(k) . . . H(2) H(1)

            as returned by CGEQLF. Q is of order m if SIDE = 'L' and of order n
            if SIDE = 'R'.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left
                     = 'R': apply Q or Q**H from the Right

           TRANS

                     TRANS is CHARACTER*1
                     = 'N': apply Q  (No transpose)
                     = 'C': apply Q**H (Conjugate transpose)

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines
                     the matrix Q.
                     If SIDE = 'L', M >= K >= 0;
                     if SIDE = 'R', N >= K >= 0.

           A

                     A is COMPLEX array, dimension (LDA,K)
                     The i-th column must contain the vector which defines the
                     elementary reflector H(i), for i = 1,2,...,k, as returned by
                     CGEQLF in the last k columns of its array argument A.
                     A is modified by the routine but restored on exit.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.
                     If SIDE = 'L', LDA >= max(1,M);
                     if SIDE = 'R', LDA >= max(1,N).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGEQLF.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the m-by-n matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension
                                              (N) if SIDE = 'L',
                                              (M) if SIDE = 'R'

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunm2r (character SIDE, character TRANS, integer M, integer N, integer K, complex,
       dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU, complex, dimension( ldc,
       * ) C, integer LDC, complex, dimension( * ) WORK, integer INFO)
       CUNM2R multiplies a general matrix by the unitary matrix from a QR factorization
       determined by cgeqrf (unblocked algorithm).

       Purpose:

            CUNM2R overwrites the general complex m-by-n matrix C with

                  Q * C  if SIDE = 'L' and TRANS = 'N', or

                  Q**H* C  if SIDE = 'L' and TRANS = 'C', or

                  C * Q  if SIDE = 'R' and TRANS = 'N', or

                  C * Q**H if SIDE = 'R' and TRANS = 'C',

            where Q is a complex unitary matrix defined as the product of k
            elementary reflectors

                  Q = H(1) H(2) . . . H(k)

            as returned by CGEQRF. Q is of order m if SIDE = 'L' and of order n
            if SIDE = 'R'.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left
                     = 'R': apply Q or Q**H from the Right

           TRANS

                     TRANS is CHARACTER*1
                     = 'N': apply Q  (No transpose)
                     = 'C': apply Q**H (Conjugate transpose)

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines
                     the matrix Q.
                     If SIDE = 'L', M >= K >= 0;
                     if SIDE = 'R', N >= K >= 0.

           A

                     A is COMPLEX array, dimension (LDA,K)
                     The i-th column must contain the vector which defines the
                     elementary reflector H(i), for i = 1,2,...,k, as returned by
                     CGEQRF in the first k columns of its array argument A.
                     A is modified by the routine but restored on exit.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.
                     If SIDE = 'L', LDA >= max(1,M);
                     if SIDE = 'R', LDA >= max(1,N).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGEQRF.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the m-by-n matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension
                                              (N) if SIDE = 'L',
                                              (M) if SIDE = 'R'

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunmbr (character VECT, character SIDE, character TRANS, integer M, integer N,
       integer K, complex, dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU,
       complex, dimension( ldc, * ) C, integer LDC, complex, dimension( * ) WORK, integer LWORK,
       integer INFO)
       CUNMBR

       Purpose:

            If VECT = 'Q', CUNMBR 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

            If VECT = 'P', CUNMBR overwrites the general complex M-by-N matrix C
            with
                            SIDE = 'L'     SIDE = 'R'
            TRANS = 'N':      P * C          C * P
            TRANS = 'C':      P**H * C       C * P**H

            Here Q and P**H are the unitary matrices determined by CGEBRD when
            reducing a complex matrix A to bidiagonal form: A = Q * B * P**H. Q
            and P**H are defined as products of elementary reflectors H(i) and
            G(i) respectively.

            Let nq = m if SIDE = 'L' and nq = n if SIDE = 'R'. Thus nq is the
            order of the unitary matrix Q or P**H that is applied.

            If VECT = 'Q', A is assumed to have been an NQ-by-K matrix:
            if nq >= k, Q = H(1) H(2) . . . H(k);
            if nq < k, Q = H(1) H(2) . . . H(nq-1).

            If VECT = 'P', A is assumed to have been a K-by-NQ matrix:
            if k < nq, P = G(1) G(2) . . . G(k);
            if k >= nq, P = G(1) G(2) . . . G(nq-1).

       Parameters
           VECT

                     VECT is CHARACTER*1
                     = 'Q': apply Q or Q**H;
                     = 'P': apply P or P**H.

           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q, Q**H, P or P**H from the Left;
                     = 'R': apply Q, Q**H, P or P**H from the Right.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  No transpose, apply Q or P;
                     = 'C':  Conjugate transpose, apply Q**H or P**H.

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           K

                     K is INTEGER
                     If VECT = 'Q', the number of columns in the original
                     matrix reduced by CGEBRD.
                     If VECT = 'P', the number of rows in the original
                     matrix reduced by CGEBRD.
                     K >= 0.

           A

                     A is COMPLEX array, dimension
                                           (LDA,min(nq,K)) if VECT = 'Q'
                                           (LDA,nq)        if VECT = 'P'
                     The vectors which define the elementary reflectors H(i) and
                     G(i), whose products determine the matrices Q and P, as
                     returned by CGEBRD.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.
                     If VECT = 'Q', LDA >= max(1,nq);
                     if VECT = 'P', LDA >= max(1,min(nq,K)).

           TAU

                     TAU is COMPLEX array, dimension (min(nq,K))
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i) or G(i) which determines Q or P, as returned
                     by CGEBRD in the array argument TAUQ or TAUP.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q
                     or P*C or P**H*C or C*P or C*P**H.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If SIDE = 'L', LWORK >= max(1,N);
                     if SIDE = 'R', LWORK >= max(1,M);
                     if N = 0 or M = 0, LWORK >= 1.
                     For optimum performance LWORK >= max(1,N*NB) if SIDE = 'L',
                     and LWORK >= max(1,M*NB) if SIDE = 'R', where NB is the
                     optimal blocksize. (NB = 0 if M = 0 or N = 0.)

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunmhr (character SIDE, character TRANS, integer M, integer N, integer ILO, integer
       IHI, complex, dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU, complex,
       dimension( ldc, * ) C, integer LDC, complex, dimension( * ) WORK, integer LWORK, integer
       INFO)
       CUNMHR

       Purpose:

            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).

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left;
                     = 'R': apply Q or Q**H from the Right.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N': apply Q  (No transpose)
                     = 'C': apply Q**H (Conjugate transpose)

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           ILO

                     ILO is INTEGER

           IHI

                     IHI is INTEGER

                     ILO and IHI must have the same values as in the previous call
                     of CGEHRD. Q is equal to the unit matrix except in the
                     submatrix Q(ilo+1:ihi,ilo+1:ihi).
                     If SIDE = 'L', then 1 <= ILO <= IHI <= M, if M > 0, and
                     ILO = 1 and IHI = 0, if M = 0;
                     if SIDE = 'R', then 1 <= ILO <= IHI <= N, if N > 0, and
                     ILO = 1 and IHI = 0, if N = 0.

           A

                     A is COMPLEX array, dimension
                                          (LDA,M) if SIDE = 'L'
                                          (LDA,N) if SIDE = 'R'
                     The vectors which define the elementary reflectors, as
                     returned by CGEHRD.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.
                     LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'.

           TAU

                     TAU is COMPLEX array, dimension
                                          (M-1) if SIDE = 'L'
                                          (N-1) if SIDE = 'R'
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGEHRD.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If SIDE = 'L', LWORK >= max(1,N);
                     if SIDE = 'R', LWORK >= max(1,M).
                     For optimum performance LWORK >= N*NB if SIDE = 'L', and
                     LWORK >= M*NB if SIDE = 'R', where NB is the optimal
                     blocksize.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunml2 (character SIDE, character TRANS, integer M, integer N, integer K, complex,
       dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU, complex, dimension( ldc,
       * ) C, integer LDC, complex, dimension( * ) WORK, integer INFO)
       CUNML2 multiplies a general matrix by the unitary matrix from a LQ factorization
       determined by cgelqf (unblocked algorithm).

       Purpose:

            CUNML2 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(k)**H . . . H(2)**H H(1)**H

            as returned by CGELQF. Q is of order m if SIDE = 'L' and of order n
            if SIDE = 'R'.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left
                     = 'R': apply Q or Q**H from the Right

           TRANS

                     TRANS is CHARACTER*1
                     = 'N': apply Q  (No transpose)
                     = 'C': apply Q**H (Conjugate transpose)

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines
                     the matrix Q.
                     If SIDE = 'L', M >= K >= 0;
                     if SIDE = 'R', N >= K >= 0.

           A

                     A is COMPLEX array, dimension
                                          (LDA,M) if SIDE = 'L',
                                          (LDA,N) if SIDE = 'R'
                     The i-th row must contain the vector which defines the
                     elementary reflector H(i), for i = 1,2,...,k, as returned by
                     CGELQF in the first k rows of its array argument A.
                     A is modified by the routine but restored on exit.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= max(1,K).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGELQF.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the m-by-n matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension
                                              (N) if SIDE = 'L',
                                              (M) if SIDE = 'R'

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunmlq (character SIDE, character TRANS, integer M, integer N, integer K, complex,
       dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU, complex, dimension( ldc,
       * ) C, integer LDC, complex, dimension( * ) WORK, integer LWORK, integer INFO)
       CUNMLQ

       Purpose:

            CUNMLQ 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(k)**H . . . H(2)**H H(1)**H

            as returned by CGELQF. Q is of order M if SIDE = 'L' and of order N
            if SIDE = 'R'.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left;
                     = 'R': apply Q or Q**H from the Right.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  No transpose, apply Q;
                     = 'C':  Conjugate transpose, apply Q**H.

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines
                     the matrix Q.
                     If SIDE = 'L', M >= K >= 0;
                     if SIDE = 'R', N >= K >= 0.

           A

                     A is COMPLEX array, dimension
                                          (LDA,M) if SIDE = 'L',
                                          (LDA,N) if SIDE = 'R'
                     The i-th row must contain the vector which defines the
                     elementary reflector H(i), for i = 1,2,...,k, as returned by
                     CGELQF in the first k rows of its array argument A.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= max(1,K).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGELQF.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If SIDE = 'L', LWORK >= max(1,N);
                     if SIDE = 'R', LWORK >= max(1,M).
                     For good performance, LWORK should generally be larger.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunmql (character SIDE, character TRANS, integer M, integer N, integer K, complex,
       dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU, complex, dimension( ldc,
       * ) C, integer LDC, complex, dimension( * ) WORK, integer LWORK, integer INFO)
       CUNMQL

       Purpose:

            CUNMQL 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(k) . . . H(2) H(1)

            as returned by CGEQLF. Q is of order M if SIDE = 'L' and of order N
            if SIDE = 'R'.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left;
                     = 'R': apply Q or Q**H from the Right.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  No transpose, apply Q;
                     = 'C':  Conjugate transpose, apply Q**H.

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines
                     the matrix Q.
                     If SIDE = 'L', M >= K >= 0;
                     if SIDE = 'R', N >= K >= 0.

           A

                     A is COMPLEX array, dimension (LDA,K)
                     The i-th column must contain the vector which defines the
                     elementary reflector H(i), for i = 1,2,...,k, as returned by
                     CGEQLF in the last k columns of its array argument A.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.
                     If SIDE = 'L', LDA >= max(1,M);
                     if SIDE = 'R', LDA >= max(1,N).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGEQLF.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If SIDE = 'L', LWORK >= max(1,N);
                     if SIDE = 'R', LWORK >= max(1,M).
                     For good performance, LWORK should generally be larger.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunmqr (character SIDE, character TRANS, integer M, integer N, integer K, complex,
       dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU, complex, dimension( ldc,
       * ) C, integer LDC, complex, dimension( * ) WORK, integer LWORK, integer INFO)
       CUNMQR

       Purpose:

            CUNMQR overwrites the general complex M-by-N matrix C with

                            SIDE = 'L'     SIDE = 'R'
            TRANS = 'N':      Q * C          C * Q
            TRANS = 'C':      Q**H * C       C * Q**H

            where Q is a complex unitary matrix defined as the product of k
            elementary reflectors

                  Q = H(1) H(2) . . . H(k)

            as returned by CGEQRF. Q is of order M if SIDE = 'L' and of order N
            if SIDE = 'R'.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left;
                     = 'R': apply Q or Q**H from the Right.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  No transpose, apply Q;
                     = 'C':  Conjugate transpose, apply Q**H.

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines
                     the matrix Q.
                     If SIDE = 'L', M >= K >= 0;
                     if SIDE = 'R', N >= K >= 0.

           A

                     A is COMPLEX array, dimension (LDA,K)
                     The i-th column must contain the vector which defines the
                     elementary reflector H(i), for i = 1,2,...,k, as returned by
                     CGEQRF in the first k columns of its array argument A.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.
                     If SIDE = 'L', LDA >= max(1,M);
                     if SIDE = 'R', LDA >= max(1,N).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGEQRF.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If SIDE = 'L', LWORK >= max(1,N);
                     if SIDE = 'R', LWORK >= max(1,M).
                     For good performance, LWORK should generally be larger.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunmr2 (character SIDE, character TRANS, integer M, integer N, integer K, complex,
       dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU, complex, dimension( ldc,
       * ) C, integer LDC, complex, dimension( * ) WORK, integer INFO)
       CUNMR2 multiplies a general matrix by the unitary matrix from a RQ factorization
       determined by cgerqf (unblocked algorithm).

       Purpose:

            CUNMR2 overwrites the general complex m-by-n matrix C with

                  Q * C  if SIDE = 'L' and TRANS = 'N', or

                  Q**H* C  if SIDE = 'L' and TRANS = 'C', or

                  C * Q  if SIDE = 'R' and TRANS = 'N', or

                  C * Q**H if SIDE = 'R' and TRANS = 'C',

            where Q is a complex unitary matrix defined as the product of k
            elementary reflectors

                  Q = H(1)**H H(2)**H . . . H(k)**H

            as returned by CGERQF. Q is of order m if SIDE = 'L' and of order n
            if SIDE = 'R'.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left
                     = 'R': apply Q or Q**H from the Right

           TRANS

                     TRANS is CHARACTER*1
                     = 'N': apply Q  (No transpose)
                     = 'C': apply Q**H (Conjugate transpose)

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines
                     the matrix Q.
                     If SIDE = 'L', M >= K >= 0;
                     if SIDE = 'R', N >= K >= 0.

           A

                     A is COMPLEX array, dimension
                                          (LDA,M) if SIDE = 'L',
                                          (LDA,N) if SIDE = 'R'
                     The i-th row must contain the vector which defines the
                     elementary reflector H(i), for i = 1,2,...,k, as returned by
                     CGERQF in the last k rows of its array argument A.
                     A is modified by the routine but restored on exit.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= max(1,K).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGERQF.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the m-by-n matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension
                                              (N) if SIDE = 'L',
                                              (M) if SIDE = 'R'

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunmr3 (character SIDE, character TRANS, integer M, integer N, integer K, integer
       L, complex, dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU, complex,
       dimension( ldc, * ) C, integer LDC, complex, dimension( * ) WORK, integer INFO)
       CUNMR3 multiplies a general matrix by the unitary matrix from a RZ factorization
       determined by ctzrzf (unblocked algorithm).

       Purpose:

            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'.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left
                     = 'R': apply Q or Q**H from the Right

           TRANS

                     TRANS is CHARACTER*1
                     = 'N': apply Q  (No transpose)
                     = 'C': apply Q**H (Conjugate transpose)

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines
                     the matrix Q.
                     If SIDE = 'L', M >= K >= 0;
                     if SIDE = 'R', N >= K >= 0.

           L

                     L is INTEGER
                     The number of columns of the matrix A containing
                     the meaningful part of the Householder reflectors.
                     If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0.

           A

                     A is COMPLEX array, dimension
                                          (LDA,M) if SIDE = 'L',
                                          (LDA,N) if SIDE = 'R'
                     The i-th row must contain the vector which defines the
                     elementary reflector H(i), for i = 1,2,...,k, as returned by
                     CTZRZF in the last k rows of its array argument A.
                     A is modified by the routine but restored on exit.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= max(1,K).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CTZRZF.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the m-by-n matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension
                                              (N) if SIDE = 'L',
                                              (M) if SIDE = 'R'

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     < 0: if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA

       Further Details:

   subroutine cunmrq (character SIDE, character TRANS, integer M, integer N, integer K, complex,
       dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU, complex, dimension( ldc,
       * ) C, integer LDC, complex, dimension( * ) WORK, integer LWORK, integer INFO)
       CUNMRQ

       Purpose:

            CUNMRQ overwrites the general complex M-by-N matrix C with

                            SIDE = 'L'     SIDE = 'R'
            TRANS = 'N':      Q * C          C * Q
            TRANS = 'C':      Q**H * C       C * Q**H

            where Q is a complex unitary matrix defined as the product of k
            elementary reflectors

                  Q = H(1)**H H(2)**H . . . H(k)**H

            as returned by CGERQF. Q is of order M if SIDE = 'L' and of order N
            if SIDE = 'R'.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left;
                     = 'R': apply Q or Q**H from the Right.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  No transpose, apply Q;
                     = 'C':  Conjugate transpose, apply Q**H.

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines
                     the matrix Q.
                     If SIDE = 'L', M >= K >= 0;
                     if SIDE = 'R', N >= K >= 0.

           A

                     A is COMPLEX array, dimension
                                          (LDA,M) if SIDE = 'L',
                                          (LDA,N) if SIDE = 'R'
                     The i-th row must contain the vector which defines the
                     elementary reflector H(i), for i = 1,2,...,k, as returned by
                     CGERQF in the last k rows of its array argument A.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= max(1,K).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CGERQF.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If SIDE = 'L', LWORK >= max(1,N);
                     if SIDE = 'R', LWORK >= max(1,M).
                     For good performance, LWORK should generally be larger.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cunmrz (character SIDE, character TRANS, integer M, integer N, integer K, integer
       L, complex, dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU, complex,
       dimension( ldc, * ) C, integer LDC, complex, dimension( * ) WORK, integer LWORK, integer
       INFO)
       CUNMRZ

       Purpose:

            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'.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left;
                     = 'R': apply Q or Q**H from the Right.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  No transpose, apply Q;
                     = 'C':  Conjugate transpose, apply Q**H.

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines
                     the matrix Q.
                     If SIDE = 'L', M >= K >= 0;
                     if SIDE = 'R', N >= K >= 0.

           L

                     L is INTEGER
                     The number of columns of the matrix A containing
                     the meaningful part of the Householder reflectors.
                     If SIDE = 'L', M >= L >= 0, if SIDE = 'R', N >= L >= 0.

           A

                     A is COMPLEX array, dimension
                                          (LDA,M) if SIDE = 'L',
                                          (LDA,N) if SIDE = 'R'
                     The i-th row must contain the vector which defines the
                     elementary reflector H(i), for i = 1,2,...,k, as returned by
                     CTZRZF in the last k rows of its array argument A.
                     A is modified by the routine but restored on exit.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= max(1,K).

           TAU

                     TAU is COMPLEX array, dimension (K)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CTZRZF.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If SIDE = 'L', LWORK >= max(1,N);
                     if SIDE = 'R', LWORK >= max(1,M).
                     For good performance, LWORK should generally be larger.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Contributors:
           A. Petitet, Computer Science Dept., Univ. of Tenn., Knoxville, USA

       Further Details:

   subroutine cunmtr (character SIDE, character UPLO, character TRANS, integer M, integer N,
       complex, dimension( lda, * ) A, integer LDA, complex, dimension( * ) TAU, complex,
       dimension( ldc, * ) C, integer LDC, complex, dimension( * ) WORK, integer LWORK, integer
       INFO)
       CUNMTR

       Purpose:

            CUNMTR 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
            nq-1 elementary reflectors, as returned by CHETRD:

            if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1);

            if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left;
                     = 'R': apply Q or Q**H from the Right.

           UPLO

                     UPLO is CHARACTER*1
                     = 'U': Upper triangle of A contains elementary reflectors
                            from CHETRD;
                     = 'L': Lower triangle of A contains elementary reflectors
                            from CHETRD.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  No transpose, apply Q;
                     = 'C':  Conjugate transpose, apply Q**H.

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           A

                     A is COMPLEX array, dimension
                                          (LDA,M) if SIDE = 'L'
                                          (LDA,N) if SIDE = 'R'
                     The vectors which define the elementary reflectors, as
                     returned by CHETRD.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.
                     LDA >= max(1,M) if SIDE = 'L'; LDA >= max(1,N) if SIDE = 'R'.

           TAU

                     TAU is COMPLEX array, dimension
                                          (M-1) if SIDE = 'L'
                                          (N-1) if SIDE = 'R'
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CHETRD.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If SIDE = 'L', LWORK >= max(1,N);
                     if SIDE = 'R', LWORK >= max(1,M).
                     For optimum performance LWORK >= N*NB if SIDE = 'L', and
                     LWORK >=M*NB if SIDE = 'R', where NB is the optimal
                     blocksize.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cupgtr (character UPLO, integer N, complex, dimension( * ) AP, complex, dimension(
       * ) TAU, complex, dimension( ldq, * ) Q, integer LDQ, complex, dimension( * ) WORK,
       integer INFO)
       CUPGTR

       Purpose:

            CUPGTR generates a complex unitary matrix Q which is defined as the
            product of n-1 elementary reflectors H(i) of order n, as returned by
            CHPTRD using packed storage:

            if UPLO = 'U', Q = H(n-1) . . . H(2) H(1),

            if UPLO = 'L', Q = H(1) H(2) . . . H(n-1).

       Parameters
           UPLO

                     UPLO is CHARACTER*1
                     = 'U': Upper triangular packed storage used in previous
                            call to CHPTRD;
                     = 'L': Lower triangular packed storage used in previous
                            call to CHPTRD.

           N

                     N is INTEGER
                     The order of the matrix Q. N >= 0.

           AP

                     AP is COMPLEX array, dimension (N*(N+1)/2)
                     The vectors which define the elementary reflectors, as
                     returned by CHPTRD.

           TAU

                     TAU is COMPLEX array, dimension (N-1)
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CHPTRD.

           Q

                     Q is COMPLEX array, dimension (LDQ,N)
                     The N-by-N unitary matrix Q.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q. LDQ >= max(1,N).

           WORK

                     WORK is COMPLEX array, dimension (N-1)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine cupmtr (character SIDE, character UPLO, character TRANS, integer M, integer N,
       complex, dimension( * ) AP, complex, dimension( * ) TAU, complex, dimension( ldc, * ) C,
       integer LDC, complex, dimension( * ) WORK, integer INFO)
       CUPMTR

       Purpose:

            CUPMTR 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
            nq-1 elementary reflectors, as returned by CHPTRD using packed
            storage:

            if UPLO = 'U', Q = H(nq-1) . . . H(2) H(1);

            if UPLO = 'L', Q = H(1) H(2) . . . H(nq-1).

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left;
                     = 'R': apply Q or Q**H from the Right.

           UPLO

                     UPLO is CHARACTER*1
                     = 'U': Upper triangular packed storage used in previous
                            call to CHPTRD;
                     = 'L': Lower triangular packed storage used in previous
                            call to CHPTRD.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  No transpose, apply Q;
                     = 'C':  Conjugate transpose, apply Q**H.

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           AP

                     AP is COMPLEX array, dimension
                                          (M*(M+1)/2) if SIDE = 'L'
                                          (N*(N+1)/2) if SIDE = 'R'
                     The vectors which define the elementary reflectors, as
                     returned by CHPTRD.  AP is modified by the routine but
                     restored on exit.

           TAU

                     TAU is COMPLEX array, dimension (M-1) if SIDE = 'L'
                                                or (N-1) if SIDE = 'R'
                     TAU(i) must contain the scalar factor of the elementary
                     reflector H(i), as returned by CHPTRD.

           C

                     C is COMPLEX array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX array, dimension
                                              (N) if SIDE = 'L'
                                              (M) if SIDE = 'R'

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine dorm22 (character SIDE, character TRANS, integer M, integer N, integer N1, integer
       N2, double precision, dimension( ldq, * ) Q, integer LDQ, double precision, dimension(
       ldc, * ) C, integer LDC, double precision, dimension( * ) WORK, integer LWORK, integer
       INFO)
       DORM22 multiplies a general matrix by a banded orthogonal matrix.

       Purpose

             DORM22 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'.
             The orthogonal matrix Q processes a 2-by-2 block structure

                    [  Q11  Q12  ]
                Q = [            ]
                    [  Q21  Q22  ],

             where Q12 is an N1-by-N1 lower triangular matrix and Q21 is an
             N2-by-N2 upper triangular matrix.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**T from the Left;
                     = 'R': apply Q or Q**T from the Right.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  apply Q (No transpose);
                     = 'C':  apply Q**T (Conjugate transpose).

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           N1
           N2

                     N1 is INTEGER
                     N2 is INTEGER
                     The dimension of Q12 and Q21, respectively. N1, N2 >= 0.
                     The following requirement must be satisfied:
                     N1 + N2 = M if SIDE = 'L' and N1 + N2 = N if SIDE = 'R'.

           Q

                     Q is DOUBLE PRECISION array, dimension
                                                  (LDQ,M) if SIDE = 'L'
                                                  (LDQ,N) if SIDE = 'R'

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q.
                     LDQ >= max(1,M) if SIDE = 'L'; LDQ >= max(1,N) if SIDE = 'R'.

           C

                     C is DOUBLE PRECISION array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If SIDE = 'L', LWORK >= max(1,N);
                     if SIDE = 'R', LWORK >= max(1,M).
                     For optimum performance LWORK >= M*N.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine sorm22 (character SIDE, character TRANS, integer M, integer N, integer N1, integer
       N2, real, dimension( ldq, * ) Q, integer LDQ, real, dimension( ldc, * ) C, integer LDC,
       real, dimension( * ) WORK, integer LWORK, integer INFO)
       SORM22 multiplies a general matrix by a banded orthogonal matrix.

       Purpose

             SORM22 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'.
             The orthogonal matrix Q processes a 2-by-2 block structure

                    [  Q11  Q12  ]
                Q = [            ]
                    [  Q21  Q22  ],

             where Q12 is an N1-by-N1 lower triangular matrix and Q21 is an
             N2-by-N2 upper triangular matrix.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**T from the Left;
                     = 'R': apply Q or Q**T from the Right.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  apply Q (No transpose);
                     = 'C':  apply Q**T (Conjugate transpose).

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           N1
           N2

                     N1 is INTEGER
                     N2 is INTEGER
                     The dimension of Q12 and Q21, respectively. N1, N2 >= 0.
                     The following requirement must be satisfied:
                     N1 + N2 = M if SIDE = 'L' and N1 + N2 = N if SIDE = 'R'.

           Q

                     Q is REAL array, dimension
                                         (LDQ,M) if SIDE = 'L'
                                         (LDQ,N) if SIDE = 'R'

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q.
                     LDQ >= max(1,M) if SIDE = 'L'; LDQ >= max(1,N) if SIDE = 'R'.

           C

                     C is REAL array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is REAL array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If SIDE = 'L', LWORK >= max(1,N);
                     if SIDE = 'R', LWORK >= max(1,M).
                     For optimum performance LWORK >= M*N.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

   subroutine zunm22 (character SIDE, character TRANS, integer M, integer N, integer N1, integer
       N2, complex*16, dimension( ldq, * ) Q, integer LDQ, complex*16, dimension( ldc, * ) C,
       integer LDC, complex*16, dimension( * ) WORK, integer LWORK, integer INFO)
       ZUNM22 multiplies a general matrix by a banded unitary matrix.

       Purpose

             ZUNM22 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'.
             The unitary matrix Q processes a 2-by-2 block structure

                    [  Q11  Q12  ]
                Q = [            ]
                    [  Q21  Q22  ],

             where Q12 is an N1-by-N1 lower triangular matrix and Q21 is an
             N2-by-N2 upper triangular matrix.

       Parameters
           SIDE

                     SIDE is CHARACTER*1
                     = 'L': apply Q or Q**H from the Left;
                     = 'R': apply Q or Q**H from the Right.

           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  apply Q (No transpose);
                     = 'C':  apply Q**H (Conjugate transpose).

           M

                     M is INTEGER
                     The number of rows of the matrix C. M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix C. N >= 0.

           N1
           N2

                     N1 is INTEGER
                     N2 is INTEGER
                     The dimension of Q12 and Q21, respectively. N1, N2 >= 0.
                     The following requirement must be satisfied:
                     N1 + N2 = M if SIDE = 'L' and N1 + N2 = N if SIDE = 'R'.

           Q

                     Q is COMPLEX*16 array, dimension
                                         (LDQ,M) if SIDE = 'L'
                                         (LDQ,N) if SIDE = 'R'

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q.
                     LDQ >= max(1,M) if SIDE = 'L'; LDQ >= max(1,N) if SIDE = 'R'.

           C

                     C is COMPLEX*16 array, dimension (LDC,N)
                     On entry, the M-by-N matrix C.
                     On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C. LDC >= max(1,M).

           WORK

                     WORK is COMPLEX*16 array, dimension (MAX(1,LWORK))
                     On exit, if INFO = 0, WORK(1) returns the optimal LWORK.

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.
                     If SIDE = 'L', LWORK >= max(1,N);
                     if SIDE = 'R', LWORK >= max(1,M).
                     For optimum performance LWORK >= M*N.

                     If LWORK = -1, then a workspace query is assumed; the routine
                     only calculates the optimal size of the WORK array, returns
                     this value as the first entry of the WORK array, and no error
                     message related to LWORK is issued by XERBLA.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

Author

       Generated automatically by Doxygen for LAPACK from the source code.