Provided by: liblapack-doc-man_3.6.0-2ubuntu2_all bug

NAME

       complex16_lin - complex16

   Functions
       program zchkaa
           ZCHKAA
       program zchkab
           ZCHKAB
       subroutine zchkeq (THRESH, NOUT)
           ZCHKEQ
       subroutine zchkgb (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, A,
           LA, AFAC, LAFAC, B, X, XACT, WORK, RWORK, IWORK, NOUT)
           ZCHKGB
       subroutine zchkge (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR,
           NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
           ZCHKGE
       subroutine zchkgt (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, AF, B, X, XACT, WORK,
           RWORK, IWORK, NOUT)
           ZCHKGT
       subroutine zchkhe (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
           AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
           ZCHKHE
       subroutine zchkhe_rook (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
           AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
           ZCHKHE_ROOK
       subroutine zchkhp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B,
           X, XACT, WORK, RWORK, IWORK, NOUT)
           ZCHKHP
       subroutine zchklq (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR,
           NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, NOUT)
           ZCHKLQ
       subroutine zchkpb (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
           AFAC, AINV, B, X, XACT, WORK, RWORK, NOUT)
           ZCHKPB
       subroutine zchkpo (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
           AFAC, AINV, B, X, XACT, WORK, RWORK, NOUT)
           ZCHKPO
       subroutine zchkpp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B,
           X, XACT, WORK, RWORK, NOUT)
           ZCHKPP
       subroutine zchkps (DOTYPE, NN, NVAL, NNB, NBVAL, NRANK, RANKVAL, THRESH, TSTERR, NMAX, A,
           AFAC, PERM, PIV, WORK, RWORK, NOUT)
           ZCHKPS
       subroutine zchkpt (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, D, E, B, X, XACT,
           WORK, RWORK, NOUT)
           ZCHKPT
       subroutine zchkq3 (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, THRESH, A, COPYA, S,
           TAU, WORK, RWORK, IWORK, NOUT)
           ZCHKQ3
       subroutine zchkql (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR,
           NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, NOUT)
           ZCHKQL
       subroutine zchkqr (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR,
           NMAX, A, AF, AQ, AR, AC, B, X, XACT, TAU, WORK, RWORK, IWORK, NOUT)
           ZCHKQR
       subroutine zchkqrt (THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
           ZCHKQRT
       subroutine zchkqrtp (THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
           ZCHKQRTP
       program zchkrfp
           ZCHKRFP
       subroutine zchkrq (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR,
           NMAX, A, AF, AQ, AR, AC, B, X, XACT, TAU, WORK, RWORK, IWORK, NOUT)
           ZCHKRQ
       subroutine zchksp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B,
           X, XACT, WORK, RWORK, IWORK, NOUT)
           ZCHKSP
       subroutine zchksy (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
           AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
           ZCHKSY
       subroutine zchksy_rook (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
           AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
           ZCHKSY_ROOK
       subroutine zchktb (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AB, AINV, B, X,
           XACT, WORK, RWORK, NOUT)
           ZCHKTB
       subroutine zchktp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AP, AINVP, B, X,
           XACT, WORK, RWORK, NOUT)
           ZCHKTP
       subroutine zchktr (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
           AINV, B, X, XACT, WORK, RWORK, NOUT)
           ZCHKTR
       subroutine zchktz (DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR, A, COPYA, S, TAU, WORK,
           RWORK, NOUT)
           ZCHKTZ
       subroutine zdrvab (DOTYPE, NM, MVAL, NNS, NSVAL, THRESH, NMAX, A, AFAC, B, X, WORK, RWORK,
           SWORK, IWORK, NOUT)
           ZDRVAB
       subroutine zdrvac (DOTYPE, NM, MVAL, NNS, NSVAL, THRESH, NMAX, A, AFAC, B, X, WORK, RWORK,
           SWORK, NOUT)
           ZDRVAC
       subroutine zdrvgb (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, LA, AFB, LAFB, ASAV, B,
           BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT)
           ZDRVGB
       subroutine zdrvge (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV,
           X, XACT, S, WORK, RWORK, IWORK, NOUT)
           ZDRVGE
       subroutine zdrvgt (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK,
           IWORK, NOUT)
           ZDRVGT
       subroutine zdrvhe (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
           XACT, WORK, RWORK, IWORK, NOUT)
           ZDRVHE
       subroutine zdrvhe_rook (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
           XACT, WORK, RWORK, IWORK, NOUT)
           ZDRVHE_ROOK
       subroutine zdrvhp (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
           XACT, WORK, RWORK, IWORK, NOUT)
           ZDRVHP
       subroutine zdrvls (DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB, NBVAL, NXVAL, THRESH,
           TSTERR, A, COPYA, B, COPYB, C, S, COPYS, WORK, RWORK, IWORK, NOUT)
           ZDRVLS
       subroutine zdrvpb (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV,
           X, XACT, S, WORK, RWORK, NOUT)
           ZDRVPB
       subroutine zdrvpo (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV,
           X, XACT, S, WORK, RWORK, NOUT)
           ZDRVPO
       subroutine zdrvpp (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV,
           X, XACT, S, WORK, RWORK, NOUT)
           ZDRVPP
       subroutine zdrvpt (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, D, E, B, X, XACT, WORK,
           RWORK, NOUT)
           ZDRVPT
       subroutine zdrvrf1 (NOUT, NN, NVAL, THRESH, A, LDA, ARF, WORK)
           ZDRVRF1
       subroutine zdrvrf2 (NOUT, NN, NVAL, A, LDA, ARF, AP, ASAV)
           ZDRVRF2
       subroutine zdrvrf3 (NOUT, NN, NVAL, THRESH, A, LDA, ARF, B1, B2, D_WORK_ZLANGE,
           Z_WORK_ZGEQRF, TAU)
           ZDRVRF3
       subroutine zdrvrf4 (NOUT, NN, NVAL, THRESH, C1, C2, LDC, CRF, A, LDA, D_WORK_ZLANGE)
           ZDRVRF4
       subroutine zdrvrfp (NOUT, NN, NVAL, NNS, NSVAL, NNT, NTVAL, THRESH, A, ASAV, AFAC, AINV,
           B, BSAV, XACT, X, ARF, ARFINV, Z_WORK_ZLATMS, Z_WORK_ZPOT02, Z_WORK_ZPOT03,
           D_WORK_ZLATMS, D_WORK_ZLANHE, D_WORK_ZPOT01, D_WORK_ZPOT02, D_WORK_ZPOT03)
           ZDRVRFP
       subroutine zdrvsp (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
           XACT, WORK, RWORK, IWORK, NOUT)
           ZDRVSP
       subroutine zdrvsy (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
           XACT, WORK, RWORK, IWORK, NOUT)
           ZDRVSY
       subroutine zdrvsy_rook (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
           XACT, WORK, RWORK, IWORK, NOUT)
           ZDRVSY_ROOK
       subroutine zebchvxx (THRESH, PATH)
           ZEBCHVXX
       subroutine zerrab (NUNIT)
           ZERRAB
       subroutine zerrac (NUNIT)
           ZERRAC
       subroutine zerrge (PATH, NUNIT)
           ZERRGE
       subroutine zerrgt (PATH, NUNIT)
           ZERRGT
       subroutine zerrhe (PATH, NUNIT)
           ZERRHE
       subroutine zerrlq (PATH, NUNIT)
           ZERRLQ
       subroutine zerrls (PATH, NUNIT)
           ZERRLS
       subroutine zerrpo (PATH, NUNIT)
           ZERRPO
       subroutine zerrps (PATH, NUNIT)
           ZERRPS
       subroutine zerrql (PATH, NUNIT)
           ZERRQL
       subroutine zerrqp (PATH, NUNIT)
           ZERRQP
       subroutine zerrqr (PATH, NUNIT)
           ZERRQR
       subroutine zerrqrt (PATH, NUNIT)
           ZERRQRT
       subroutine zerrqrtp (PATH, NUNIT)
           ZERRQRTP
       subroutine zerrrfp (NUNIT)
           ZERRRFP
       subroutine zerrrq (PATH, NUNIT)
           ZERRRQ
       subroutine zerrsy (PATH, NUNIT)
           ZERRSY
       subroutine zerrtr (PATH, NUNIT)
           ZERRTR
       subroutine zerrtz (PATH, NUNIT)
           ZERRTZ
       subroutine zerrvx (PATH, NUNIT)
           ZERRVX
       subroutine zgbt01 (M, N, KL, KU, A, LDA, AFAC, LDAFAC, IPIV, WORK, RESID)
           ZGBT01
       subroutine zgbt02 (TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, RESID)
           ZGBT02
       subroutine zgbt05 (TRANS, N, KL, KU, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR,
           BERR, RESLTS)
           ZGBT05
       subroutine zgelqs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO)
           ZGELQS
       logical function zgennd (M, N, A, LDA)
           ZGENND
       subroutine zgeqls (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO)
           ZGEQLS
       subroutine zgeqrs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO)
           ZGEQRS
       subroutine zgerqs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO)
           ZGERQS
       subroutine zget01 (M, N, A, LDA, AFAC, LDAFAC, IPIV, RWORK, RESID)
           ZGET01
       subroutine zget02 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
           ZGET02
       subroutine zget03 (N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID)
           ZGET03
       subroutine zget04 (N, NRHS, X, LDX, XACT, LDXACT, RCOND, RESID)
           ZGET04
       subroutine zget07 (TRANS, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, CHKFERR,
           BERR, RESLTS)
           ZGET07
       subroutine zget08 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
           ZGET08
       subroutine zgtt01 (N, DL, D, DU, DLF, DF, DUF, DU2, IPIV, WORK, LDWORK, RWORK, RESID)
           ZGTT01
       subroutine zgtt02 (TRANS, N, NRHS, DL, D, DU, X, LDX, B, LDB, RESID)
           ZGTT02
       subroutine zgtt05 (TRANS, N, NRHS, DL, D, DU, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR,
           RESLTS)
           ZGTT05
       subroutine zhet01 (UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
           ZHET01
       subroutine zhet01_rook (UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
           ZHET01_ROOK
       subroutine zhpt01 (UPLO, N, A, AFAC, IPIV, C, LDC, RWORK, RESID)
           ZHPT01
       subroutine zlahilb (N, NRHS, A, LDA, X, LDX, B, LDB, WORK, INFO, PATH)
           ZLAHILB
       subroutine zlaipd (N, A, INDA, VINDA)
           ZLAIPD
       subroutine zlaptm (UPLO, N, NRHS, ALPHA, D, E, X, LDX, BETA, B, LDB)
           ZLAPTM
       subroutine zlarhs (PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB,
           ISEED, INFO)
           ZLARHS
       subroutine zlatb4 (PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST)
           ZLATB4
       subroutine zlatb5 (PATH, IMAT, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST)
           ZLATB5
       subroutine zlatsp (UPLO, N, X, ISEED)
           ZLATSP
       subroutine zlatsy (UPLO, N, X, LDX, ISEED)
           ZLATSY
       subroutine zlattb (IMAT, UPLO, TRANS, DIAG, ISEED, N, KD, AB, LDAB, B, WORK, RWORK, INFO)
           ZLATTB
       subroutine zlattp (IMAT, UPLO, TRANS, DIAG, ISEED, N, AP, B, WORK, RWORK, INFO)
           ZLATTP
       subroutine zlattr (IMAT, UPLO, TRANS, DIAG, ISEED, N, A, LDA, B, WORK, RWORK, INFO)
           ZLATTR
       subroutine zlavhe (UPLO, TRANS, DIAG, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
           ZLAVHE
       subroutine zlavhe_rook (UPLO, TRANS, DIAG, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
           ZLAVHE_ROOK
       subroutine zlavhp (UPLO, TRANS, DIAG, N, NRHS, A, IPIV, B, LDB, INFO)
           ZLAVHP
       subroutine zlavsp (UPLO, TRANS, DIAG, N, NRHS, A, IPIV, B, LDB, INFO)
           ZLAVSP
       subroutine zlavsy (UPLO, TRANS, DIAG, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
           ZLAVSY
       subroutine zlavsy_rook (UPLO, TRANS, DIAG, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
           ZLAVSY_ROOK
       subroutine zlqt01 (M, N, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT)
           ZLQT01
       subroutine zlqt02 (M, N, K, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT)
           ZLQT02
       subroutine zlqt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT)
           ZLQT03
       subroutine zpbt01 (UPLO, N, KD, A, LDA, AFAC, LDAFAC, RWORK, RESID)
           ZPBT01
       subroutine zpbt02 (UPLO, N, KD, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
           ZPBT02
       subroutine zpbt05 (UPLO, N, KD, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR,
           RESLTS)
           ZPBT05
       subroutine zpot01 (UPLO, N, A, LDA, AFAC, LDAFAC, RWORK, RESID)
           ZPOT01
       subroutine zpot02 (UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
           ZPOT02
       subroutine zpot03 (UPLO, N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID)
           ZPOT03
       subroutine zpot05 (UPLO, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR,
           RESLTS)
           ZPOT05
       subroutine zpot06 (UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
           ZPOT06
       subroutine zppt01 (UPLO, N, A, AFAC, RWORK, RESID)
           ZPPT01
       subroutine zppt02 (UPLO, N, NRHS, A, X, LDX, B, LDB, RWORK, RESID)
           ZPPT02
       subroutine zppt03 (UPLO, N, A, AINV, WORK, LDWORK, RWORK, RCOND, RESID)
           ZPPT03
       subroutine zppt05 (UPLO, N, NRHS, AP, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS)
           ZPPT05
       subroutine zpst01 (UPLO, N, A, LDA, AFAC, LDAFAC, PERM, LDPERM, PIV, RWORK, RESID, RANK)
           ZPST01
       subroutine zptt01 (N, D, E, DF, EF, WORK, RESID)
           ZPTT01
       subroutine zptt02 (UPLO, N, NRHS, D, E, X, LDX, B, LDB, RESID)
           ZPTT02
       subroutine zptt05 (N, NRHS, D, E, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS)
           ZPTT05
       subroutine zqlt01 (M, N, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT)
           ZQLT01
       subroutine zqlt02 (M, N, K, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT)
           ZQLT02
       subroutine zqlt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT)
           ZQLT03
       double precision function zqpt01 (M, N, K, A, AF, LDA, TAU, JPVT, WORK, LWORK)
           ZQPT01
       subroutine zqrt01 (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT)
           ZQRT01
       subroutine zqrt01p (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT)
           ZQRT01P
       subroutine zqrt02 (M, N, K, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT)
           ZQRT02
       subroutine zqrt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT)
           ZQRT03
       subroutine zqrt04 (M, N, NB, RESULT)
           ZQRT04
       subroutine zqrt05 (M, N, L, NB, RESULT)
           ZQRT05
       double precision function zqrt11 (M, K, A, LDA, TAU, WORK, LWORK)
           ZQRT11
       double precision function zqrt12 (M, N, A, LDA, S, WORK, LWORK, RWORK)
           ZQRT12
       subroutine zqrt13 (SCALE, M, N, A, LDA, NORMA, ISEED)
           ZQRT13
       double precision function zqrt14 (TRANS, M, N, NRHS, A, LDA, X, LDX, WORK, LWORK)
           ZQRT14
       subroutine zqrt15 (SCALE, RKSEL, M, N, NRHS, A, LDA, B, LDB, S, RANK, NORMA, NORMB, ISEED,
           WORK, LWORK)
           ZQRT15
       subroutine zqrt16 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
           ZQRT16
       double precision function zqrt17 (TRANS, IRESID, M, N, NRHS, A, LDA, X, LDX, B, LDB, C,
           WORK, LWORK)
           ZQRT17
       subroutine zrqt01 (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT)
           ZRQT01
       subroutine zrqt02 (M, N, K, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT)
           ZRQT02
       subroutine zrqt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT)
           ZRQT03
       double precision function zrzt01 (M, N, A, AF, LDA, TAU, WORK, LWORK)
           ZRZT01
       double precision function zrzt02 (M, N, AF, LDA, TAU, WORK, LWORK)
           ZRZT02
       subroutine zsbmv (UPLO, N, K, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)
           ZSBMV
       subroutine zspt01 (UPLO, N, A, AFAC, IPIV, C, LDC, RWORK, RESID)
           ZSPT01
       subroutine zspt02 (UPLO, N, NRHS, A, X, LDX, B, LDB, RWORK, RESID)
           ZSPT02
       subroutine zspt03 (UPLO, N, A, AINV, WORK, LDW, RWORK, RCOND, RESID)
           ZSPT03
       subroutine zsyt01 (UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
           ZSYT01
       subroutine zsyt01_rook (UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
           ZSYT01_ROOK
       subroutine zsyt02 (UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
           ZSYT02
       subroutine zsyt03 (UPLO, N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID)
           ZSYT03
       subroutine ztbt02 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, X, LDX, B, LDB, WORK, RWORK,
           RESID)
           ZTBT02
       subroutine ztbt03 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, SCALE, CNORM, TSCAL, X, LDX,
           B, LDB, WORK, RESID)
           ZTBT03
       subroutine ztbt05 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT,
           FERR, BERR, RESLTS)
           ZTBT05
       subroutine ztbt06 (RCOND, RCONDC, UPLO, DIAG, N, KD, AB, LDAB, RWORK, RAT)
           ZTBT06
       subroutine ztpt01 (UPLO, DIAG, N, AP, AINVP, RCOND, RWORK, RESID)
           ZTPT01
       subroutine ztpt02 (UPLO, TRANS, DIAG, N, NRHS, AP, X, LDX, B, LDB, WORK, RWORK, RESID)
           ZTPT02
       subroutine ztpt03 (UPLO, TRANS, DIAG, N, NRHS, AP, SCALE, CNORM, TSCAL, X, LDX, B, LDB,
           WORK, RESID)
           ZTPT03
       subroutine ztpt05 (UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, X, LDX, XACT, LDXACT, FERR,
           BERR, RESLTS)
           ZTPT05
       subroutine ztpt06 (RCOND, RCONDC, UPLO, DIAG, N, AP, RWORK, RAT)
           ZTPT06
       subroutine ztrt01 (UPLO, DIAG, N, A, LDA, AINV, LDAINV, RCOND, RWORK, RESID)
           ZTRT01
       subroutine ztrt02 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, X, LDX, B, LDB, WORK, RWORK, RESID)
           ZTRT02
       subroutine ztrt03 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, SCALE, CNORM, TSCAL, X, LDX, B,
           LDB, WORK, RESID)
           ZTRT03
       subroutine ztrt05 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR,
           BERR, RESLTS)
           ZTRT05
       subroutine ztrt06 (RCOND, RCONDC, UPLO, DIAG, N, A, LDA, RWORK, RAT)
           ZTRT06

Detailed Description

       This is the group of complex16 LAPACK TESTING LIN routines.

Function Documentation

   program zchkaa ()
       ZCHKAA

       Purpose:

            ZCHKAA is the main test program for the COMPLEX*16 linear equation
            routines.

            The program must be driven by a short data file. The first 15 records
            (not including the first comment  line) specify problem dimensions
            and program options using list-directed input. The remaining lines
            specify the LAPACK test paths and the number of matrix types to use
            in testing.  An annotated example of a data file can be obtained by
            deleting the first 3 characters from the following 42 lines:
            Data file for testing COMPLEX*16 LAPACK linear equation routines
            7                      Number of values of M
            0 1 2 3 5 10 16        Values of M (row dimension)
            7                      Number of values of N
            0 1 2 3 5 10 16        Values of N (column dimension)
            1                      Number of values of NRHS
            2                      Values of NRHS (number of right hand sides)
            5                      Number of values of NB
            1 3 3 3 20             Values of NB (the blocksize)
            1 0 5 9 1              Values of NX (crossover point)
            3                      Number of values of RANK
            30 50 90               Values of rank (as a % of N)
            30.0                   Threshold value of test ratio
            T                      Put T to test the LAPACK routines
            T                      Put T to test the driver routines
            T                      Put T to test the error exits
            ZGE   11               List types on next line if 0 < NTYPES < 11
            ZGB    8               List types on next line if 0 < NTYPES <  8
            ZGT   12               List types on next line if 0 < NTYPES < 12
            ZPO    9               List types on next line if 0 < NTYPES <  9
            ZPS    9               List types on next line if 0 < NTYPES <  9
            ZPP    9               List types on next line if 0 < NTYPES <  9
            ZPB    8               List types on next line if 0 < NTYPES <  8
            ZPT   12               List types on next line if 0 < NTYPES < 12
            ZHE   10               List types on next line if 0 < NTYPES < 10
            ZHR   10               List types on next line if 0 < NTYPES < 10
            ZHP   10               List types on next line if 0 < NTYPES < 10
            ZSY   11               List types on next line if 0 < NTYPES < 11
            ZSR   11               List types on next line if 0 < NTYPES < 11
            ZSP   11               List types on next line if 0 < NTYPES < 11
            ZTR   18               List types on next line if 0 < NTYPES < 18
            ZTP   18               List types on next line if 0 < NTYPES < 18
            ZTB   17               List types on next line if 0 < NTYPES < 17
            ZQR    8               List types on next line if 0 < NTYPES <  8
            ZRQ    8               List types on next line if 0 < NTYPES <  8
            ZLQ    8               List types on next line if 0 < NTYPES <  8
            ZQL    8               List types on next line if 0 < NTYPES <  8
            ZQP    6               List types on next line if 0 < NTYPES <  6
            ZTZ    3               List types on next line if 0 < NTYPES <  3
            ZLS    6               List types on next line if 0 < NTYPES <  6
            ZEQ
            ZQT
            ZQX

             NMAX    INTEGER
                     The maximum allowable value for M and N.

             MAXIN   INTEGER
                     The number of different values that can be used for each of
                     M, N, NRHS, NB, NX and RANK

             MAXRHS  INTEGER
                     The maximum number of right hand sides

             MATMAX  INTEGER
                     The maximum number of matrix types to use for testing

             NIN     INTEGER
                     The unit number for input

             NOUT    INTEGER
                     The unit number for output

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   program zchkab ()
       ZCHKAB

       Purpose:

            ZCHKAB is the test program for the COMPLEX*16 LAPACK
            ZCGESV/ZCPOSV routine

            The program must be driven by a short data file. The first 5 records
            specify problem dimensions and program options using list-directed
            input. The remaining lines specify the LAPACK test paths and the
            number of matrix types to use in testing.  An annotated example of a
            data file can be obtained by deleting the first 3 characters from the
            following 9 lines:
            Data file for testing COMPLEX*16 LAPACK ZCGESV
            7                      Number of values of M
            0 1 2 3 5 10 16        Values of M (row dimension)
            1                      Number of values of NRHS
            2                      Values of NRHS (number of right hand sides)
            20.0                   Threshold value of test ratio
            T                      Put T to test the LAPACK routine
            T                      Put T to test the error exits
            DGE    11              List types on next line if 0 < NTYPES < 11
            DPO    9               List types on next line if 0 < NTYPES <  9

             NMAX    INTEGER
                     The maximum allowable value for N

             MAXIN   INTEGER
                     The number of different values that can be used for each of
                     M, N, NRHS, NB, and NX

             MAXRHS  INTEGER
                     The maximum number of right hand sides

             NIN     INTEGER
                     The unit number for input

             NOUT    INTEGER
                     The unit number for output

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           April 2012

   subroutine zchkeq (double precision THRESH, integer NOUT)
       ZCHKEQ

       Purpose:

            ZCHKEQ tests ZGEEQU, ZGBEQU, ZPOEQU, ZPPEQU and ZPBEQU

       Parameters:
           THRESH

                     THRESH is DOUBLE PRECISION
                     Threshold for testing routines. Should be between 2 and 10.

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkgb (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
       integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
       integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
       complex*16, dimension( * ) A, integer LA, complex*16, dimension( * ) AFAC, integer LAFAC,
       complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
       XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
       dimension( * ) IWORK, integer NOUT)
       ZCHKGB

       Purpose:

            ZCHKGB tests ZGBTRF, -TRS, -RFS, and -CON

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB contained in the vector NBVAL.

           NBVAL

                     NBVAL is INTEGER array, dimension (NBVAL)
                     The values of the blocksize NB.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           A

                     A is COMPLEX*16 array, dimension (LA)

           LA

                     LA is INTEGER
                     The length of the array A.  LA >= (KLMAX+KUMAX+1)*NMAX
                     where KLMAX is the largest entry in the local array KLVAL,
                           KUMAX is the largest entry in the local array KUVAL and
                           NMAX is the largest entry in the input array NVAL.

           AFAC

                     AFAC is COMPLEX*16 array, dimension (LAFAC)

           LAFAC

                     LAFAC is INTEGER
                     The length of the array AFAC. LAFAC >= (2*KLMAX+KUMAX+1)*NMAX
                     where KLMAX is the largest entry in the local array KLVAL,
                           KUMAX is the largest entry in the local array KUVAL and
                           NMAX is the largest entry in the input array NVAL.

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NSMAX,NMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (max(NMAX,2*NSMAX))

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkge (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
       integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
       integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
       integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16,
       dimension( * ) AINV, complex*16, dimension( * ) B, complex*16, dimension( * ) X,
       complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
       ZCHKGE

       Purpose:

            ZCHKGE tests ZGETRF, -TRI, -TRS, -RFS, and -CON.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB contained in the vector NBVAL.

           NBVAL

                     NBVAL is INTEGER array, dimension (NBVAL)
                     The values of the blocksize NB.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for M or N, used in dimensioning
                     the work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (max(2*NMAX,2*NSMAX+NWORK))

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkgt (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
       complex*16, dimension( * ) A, complex*16, dimension( * ) AF, complex*16, dimension( * ) B,
       complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension( * )
       WORK, double precision, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
       ZCHKGT

       Purpose:

            ZCHKGT tests ZGTTRF, -TRS, -RFS, and -CON

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           A

                     A is COMPLEX*16 array, dimension (NMAX*4)

           AF

                     AF is COMPLEX*16 array, dimension (NMAX*4)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (max(NMAX)+2*NSMAX)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkhe (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * ) NSVAL,
       double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * ) A,
       complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16, dimension( *
       ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension(
       * ) WORK, double precision, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer
       NOUT)
       ZCHKHE

       Purpose:

            ZCHKHE tests ZHETRF, -TRI2, -TRS, -TRS2, -RFS, and -CON.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB contained in the vector NBVAL.

           NBVAL

                     NBVAL is INTEGER array, dimension (NBVAL)
                     The values of the blocksize NB.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX))

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zchkhe_rook (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * )
       NVAL, integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * )
       NSVAL, double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * )
       A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16,
       dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT,
       complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
       dimension( * ) IWORK, integer NOUT)
       ZCHKHE_ROOK

       Purpose:

            ZCHKHE_ROOK tests ZHETRF_ROOK, -TRI_ROOK, -TRS_ROOK,
            and -CON_ROOK.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB contained in the vector NBVAL.

           NBVAL

                     NBVAL is INTEGER array, dimension (NBVAL)
                     The values of the blocksize NB.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is CCOMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is CCOMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)

           IWORK

                     IWORK is INTEGER array, dimension (2*NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zchkhp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
       integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16,
       dimension( * ) AINV, complex*16, dimension( * ) B, complex*16, dimension( * ) X,
       complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
       ZCHKHP

       Purpose:

            ZCHKHP tests ZHPTRF, -TRI, -TRS, -RFS, and -CON

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           AFAC

                     AFAC is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           AINV

                     AINV is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(2,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array,
                                            dimension (NMAX+2*NSMAX)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchklq (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
       integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
       integer, dimension( * ) NXVAL, integer NRHS, double precision THRESH, logical TSTERR,
       integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AF, complex*16,
       dimension( * ) AQ, complex*16, dimension( * ) AL, complex*16, dimension( * ) AC,
       complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
       XACT, complex*16, dimension( * ) TAU, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer NOUT)
       ZCHKLQ

       Purpose:

            ZCHKLQ tests ZGELQF, ZUNGLQ and CUNMLQ.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB and NX contained in the
                     vectors NBVAL and NXVAL.  The blocking parameters are used
                     in pairs (NB,NX).

           NBVAL

                     NBVAL is INTEGER array, dimension (NNB)
                     The values of the blocksize NB.

           NXVAL

                     NXVAL is INTEGER array, dimension (NNB)
                     The values of the crossover point NX.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for M or N, used in dimensioning
                     the work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AF

                     AF is COMPLEX*16 array, dimension (NMAX*NMAX)

           AQ

                     AQ is COMPLEX*16 array, dimension (NMAX*NMAX)

           AL

                     AL is COMPLEX*16 array, dimension (NMAX*NMAX)

           AC

                     AC is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           TAU

                     TAU is COMPLEX*16 array, dimension (NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*NMAX)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkpb (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * ) NSVAL,
       double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * ) A,
       complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16, dimension( *
       ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension(
       * ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
       ZCHKPB

       Purpose:

            ZCHKPB tests ZPBTRF, -TRS, -RFS, and -CON.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB contained in the vector NBVAL.

           NBVAL

                     NBVAL is INTEGER array, dimension (NBVAL)
                     The values of the blocksize NB.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is DOUBLE PRECISION array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX)

           AINV

                     AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX)

           B

                     B is DOUBLE PRECISION array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is DOUBLE PRECISION array, dimension (NMAX*NSMAX)

           XACT

                     XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX)

           WORK

                     WORK is DOUBLE PRECISION array, dimension
                                 (NMAX*max(3,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (max(NMAX,2*NSMAX))

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkpo (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * ) NSVAL,
       double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * ) A,
       complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16, dimension( *
       ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension(
       * ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
       ZCHKPO

       Purpose:

            ZCHKPO tests ZPOTRF, -TRI, -TRS, -RFS, and -CON

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB contained in the vector NBVAL.

           NBVAL

                     NBVAL is INTEGER array, dimension (NBVAL)
                     The values of the blocksize NB.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (NMAX+2*NSMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkpp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
       integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16,
       dimension( * ) AINV, complex*16, dimension( * ) B, complex*16, dimension( * ) X,
       complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer NOUT)
       ZCHKPP

       Purpose:

            ZCHKPP tests ZPPTRF, -TRI, -TRS, -RFS, and -CON

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           AFAC

                     AFAC is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           AINV

                     AINV is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (max(NMAX,2*NSMAX))

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkps (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NNB, integer, dimension( * ) NBVAL, integer NRANK, integer, dimension( * )
       RANKVAL, double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * )
       A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) PERM, integer, dimension( *
       ) PIV, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer
       NOUT)
       ZCHKPS

       Purpose:

            ZCHKPS tests ZPSTRF.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB contained in the vector NBVAL.

           NBVAL

                     NBVAL is INTEGER array, dimension (NBVAL)
                     The values of the block size NB.

           NRANK

                     NRANK is INTEGER
                     The number of values of RANK contained in the vector RANKVAL.

           RANKVAL

                     RANKVAL is INTEGER array, dimension (NBVAL)
                     The values of the block size NB.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           PERM

                     PERM is COMPLEX*16 array, dimension (NMAX*NMAX)

           PIV

                     PIV is INTEGER array, dimension (NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*3)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkpt (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
       complex*16, dimension( * ) A, double precision, dimension( * ) D, complex*16, dimension( *
       ) E, complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( *
       ) XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer
       NOUT)
       ZCHKPT

       Purpose:

            ZCHKPT tests ZPTTRF, -TRS, -RFS, and -CON

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           A

                     A is COMPLEX*16 array, dimension (NMAX*2)

           D

                     D is DOUBLE PRECISION array, dimension (NMAX*2)

           E

                     E is COMPLEX*16 array, dimension (NMAX*2)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (max(NMAX,2*NSMAX))

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkq3 (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
       integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
       integer, dimension( * ) NXVAL, double precision THRESH, complex*16, dimension( * ) A,
       complex*16, dimension( * ) COPYA, double precision, dimension( * ) S, complex*16,
       dimension( * ) TAU, complex*16, dimension( * ) WORK, double precision, dimension( * )
       RWORK, integer, dimension( * ) IWORK, integer NOUT)
       ZCHKQ3

       Purpose:

            ZCHKQ3 tests ZGEQP3.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB and NX contained in the
                     vectors NBVAL and NXVAL.  The blocking parameters are used
                     in pairs (NB,NX).

           NBVAL

                     NBVAL is INTEGER array, dimension (NNB)
                     The values of the blocksize NB.

           NXVAL

                     NXVAL is INTEGER array, dimension (NNB)
                     The values of the crossover point NX.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           A

                     A is COMPLEX*16 array, dimension (MMAX*NMAX)
                     where MMAX is the maximum value of M in MVAL and NMAX is the
                     maximum value of N in NVAL.

           COPYA

                     COPYA is COMPLEX*16 array, dimension (MMAX*NMAX)

           S

                     S is DOUBLE PRECISION array, dimension
                                 (min(MMAX,NMAX))

           TAU

                     TAU is COMPLEX*16 array, dimension (MMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (max(M*max(M,N) + 4*min(M,N) + max(M,N)))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (4*NMAX)

           IWORK

                     IWORK is INTEGER array, dimension (2*NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkql (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
       integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
       integer, dimension( * ) NXVAL, integer NRHS, double precision THRESH, logical TSTERR,
       integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AF, complex*16,
       dimension( * ) AQ, complex*16, dimension( * ) AL, complex*16, dimension( * ) AC,
       complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
       XACT, complex*16, dimension( * ) TAU, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer NOUT)
       ZCHKQL

       Purpose:

            ZCHKQL tests ZGEQLF, ZUNGQL and CUNMQL.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB and NX contained in the
                     vectors NBVAL and NXVAL.  The blocking parameters are used
                     in pairs (NB,NX).

           NBVAL

                     NBVAL is INTEGER array, dimension (NNB)
                     The values of the blocksize NB.

           NXVAL

                     NXVAL is INTEGER array, dimension (NNB)
                     The values of the crossover point NX.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for M or N, used in dimensioning
                     the work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AF

                     AF is COMPLEX*16 array, dimension (NMAX*NMAX)

           AQ

                     AQ is COMPLEX*16 array, dimension (NMAX*NMAX)

           AL

                     AL is COMPLEX*16 array, dimension (NMAX*NMAX)

           AC

                     AC is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           TAU

                     TAU is COMPLEX*16 array, dimension (NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*NMAX)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkqr (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
       integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
       integer, dimension( * ) NXVAL, integer NRHS, double precision THRESH, logical TSTERR,
       integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AF, complex*16,
       dimension( * ) AQ, complex*16, dimension( * ) AR, complex*16, dimension( * ) AC,
       complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
       XACT, complex*16, dimension( * ) TAU, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
       ZCHKQR

       Purpose:

            ZCHKQR tests ZGEQRF, ZUNGQR and CUNMQR.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB and NX contained in the
                     vectors NBVAL and NXVAL.  The blocking parameters are used
                     in pairs (NB,NX).

           NBVAL

                     NBVAL is INTEGER array, dimension (NNB)
                     The values of the blocksize NB.

           NXVAL

                     NXVAL is INTEGER array, dimension (NNB)
                     The values of the crossover point NX.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for M or N, used in dimensioning
                     the work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AF

                     AF is COMPLEX*16 array, dimension (NMAX*NMAX)

           AQ

                     AQ is COMPLEX*16 array, dimension (NMAX*NMAX)

           AR

                     AR is COMPLEX*16 array, dimension (NMAX*NMAX)

           AC

                     AC is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           TAU

                     TAU is COMPLEX*16 array, dimension (NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*NMAX)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zchkqrt (double precision THRESH, logical TSTERR, integer NM, integer, dimension( *
       ) MVAL, integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * )
       NBVAL, integer NOUT)
       ZCHKQRT

       Purpose:

            ZCHKQRT tests ZGEQRT and ZGEMQRT.

       Parameters:
           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB contained in the vector NBVAL.

           NBVAL

                     NBVAL is INTEGER array, dimension (NBVAL)
                     The values of the blocksize NB.

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkqrtp (double precision THRESH, logical TSTERR, integer NM, integer, dimension(
       * ) MVAL, integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * )
       NBVAL, integer NOUT)
       ZCHKQRTP

       Purpose:

            ZCHKQRTP tests ZTPQRT and ZTPMQRT.

       Parameters:
           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB contained in the vector NBVAL.

           NBVAL

                     NBVAL is INTEGER array, dimension (NBVAL)
                     The values of the blocksize NB.

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   program zchkrfp ()
       ZCHKRFP

       Purpose:

            ZCHKRFP is the main test program for the COMPLEX*16 linear equation
            routines with RFP storage format

             MAXIN   INTEGER
                     The number of different values that can be used for each of
                     M, N, or NB

             MAXRHS  INTEGER
                     The maximum number of right hand sides

             NTYPES  INTEGER

             NMAX    INTEGER
                     The maximum allowable value for N.

             NIN     INTEGER
                     The unit number for input

             NOUT    INTEGER
                     The unit number for output

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           April 2012

   subroutine zchkrq (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
       integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
       integer, dimension( * ) NXVAL, integer NRHS, double precision THRESH, logical TSTERR,
       integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AF, complex*16,
       dimension( * ) AQ, complex*16, dimension( * ) AR, complex*16, dimension( * ) AC,
       complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
       XACT, complex*16, dimension( * ) TAU, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
       ZCHKRQ

       Purpose:

            ZCHKRQ tests ZGERQF, ZUNGRQ and CUNMRQ.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB and NX contained in the
                     vectors NBVAL and NXVAL.  The blocking parameters are used
                     in pairs (NB,NX).

           NBVAL

                     NBVAL is INTEGER array, dimension (NNB)
                     The values of the blocksize NB.

           NXVAL

                     NXVAL is INTEGER array, dimension (NNB)
                     The values of the crossover point NX.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for M or N, used in dimensioning
                     the work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AF

                     AF is COMPLEX*16 array, dimension (NMAX*NMAX)

           AQ

                     AQ is COMPLEX*16 array, dimension (NMAX*NMAX)

           AR

                     AR is COMPLEX*16 array, dimension (NMAX*NMAX)

           AC

                     AC is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           TAU

                     TAU is COMPLEX*16 array, dimension (NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*NMAX)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchksp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
       integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16,
       dimension( * ) AINV, complex*16, dimension( * ) B, complex*16, dimension( * ) X,
       complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
       ZCHKSP

       Purpose:

            ZCHKSP tests ZSPTRF, -TRI, -TRS, -RFS, and -CON

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           AFAC

                     AFAC is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           AINV

                     AINV is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(2,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array,
                                            dimension (NMAX+2*NSMAX)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchksy (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * ) NSVAL,
       double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * ) A,
       complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16, dimension( *
       ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension(
       * ) WORK, double precision, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer
       NOUT)
       ZCHKSY

       Purpose:

            ZCHKSY tests ZSYTRF, -TRI2, -TRS, -TRS2,  -RFS, and -CON.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB contained in the vector NBVAL.

           NBVAL

                     NBVAL is INTEGER array, dimension (NBVAL)
                     The values of the blocksize NB.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*max(2,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NSMAX)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zchksy_rook (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * )
       NVAL, integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * )
       NSVAL, double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * )
       A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16,
       dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT,
       complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
       dimension( * ) IWORK, integer NOUT)
       ZCHKSY_ROOK

       Purpose:

            ZCHKSY_ROOK tests ZSYTRF_ROOK, -TRI_ROOK, -TRS_ROOK,
            and -CON_ROOK.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB contained in the vector NBVAL.

           NBVAL

                     NBVAL is INTEGER array, dimension (NBVAL)
                     The values of the blocksize NB.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX))

           IWORK

                     IWORK is INTEGER array, dimension (2*NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zchktb (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
       integer NMAX, complex*16, dimension( * ) AB, complex*16, dimension( * ) AINV, complex*16,
       dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT,
       complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
       ZCHKTB

       Purpose:

            ZCHKTB tests ZTBTRS, -RFS, and -CON, and ZLATBS.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The leading dimension of the work arrays.
                     NMAX >= the maximum value of N in NVAL.

           AB

                     AB is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (max(NMAX,2*NSMAX))

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchktp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
       integer NMAX, complex*16, dimension( * ) AP, complex*16, dimension( * ) AINVP, complex*16,
       dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT,
       complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
       ZCHKTP

       Purpose:

            ZCHKTP tests ZTPTRI, -TRS, -RFS, and -CON, and ZLATPS

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The leading dimension of the work arrays.  NMAX >= the
                     maximumm value of N in NVAL.

           AP

                     AP is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)

           AINVP

                     AINVP is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (max(NMAX,2*NSMAX))

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchktr (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * ) NSVAL,
       double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * ) A,
       complex*16, dimension( * ) AINV, complex*16, dimension( * ) B, complex*16, dimension( * )
       X, complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer NOUT)
       ZCHKTR

       Purpose:

            ZCHKTR tests ZTRTRI, -TRS, -RFS, and -CON, and ZLATRS

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB contained in the vector NBVAL.

           NBVAL

                     NBVAL is INTEGER array, dimension (NNB)
                     The values of the blocksize NB.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The leading dimension of the work arrays.
                     NMAX >= the maximum value of N in NVAL.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (max(NMAX,2*NSMAX))

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchktz (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
       integer NN, integer, dimension( * ) NVAL, double precision THRESH, logical TSTERR,
       complex*16, dimension( * ) A, complex*16, dimension( * ) COPYA, double precision,
       dimension( * ) S, complex*16, dimension( * ) TAU, complex*16, dimension( * ) WORK, double
       precision, dimension( * ) RWORK, integer NOUT)
       ZCHKTZ

       Purpose:

            ZCHKTZ tests ZTZRZF.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           A

                     A is COMPLEX*16 array, dimension (MMAX*NMAX)
                     where MMAX is the maximum value of M in MVAL and NMAX is the
                     maximum value of N in NVAL.

           COPYA

                     COPYA is COMPLEX*16 array, dimension (MMAX*NMAX)

           S

                     S is DOUBLE PRECISION array, dimension
                                 (min(MMAX,NMAX))

           TAU

                     TAU is COMPLEX*16 array, dimension (MMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (MMAX*NMAX + 4*NMAX + MMAX)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (2*NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zdrvab (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
       integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, integer NMAX,
       complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * )
       B, complex*16, dimension( * ) X, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, complex, dimension( * ) SWORK, integer, dimension( * ) IWORK,
       integer NOUT)
       ZDRVAB

       Purpose:

            ZDRVAB tests ZCGESV

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for M or N, used in dimensioning
                     the work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)
                     where NSMAX is the largest entry in NSVAL.

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NSMAX*2))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 NMAX

           SWORK

                     SWORK is COMPLEX array, dimension
                                 (NMAX*(NSMAX+NMAX))

           IWORK

                     IWORK is INTEGER array, dimension
                                 NMAX

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvac (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
       integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, integer NMAX,
       complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * )
       B, complex*16, dimension( * ) X, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, complex, dimension(*) SWORK, integer NOUT)
       ZDRVAC

       Purpose:

            ZDRVAC tests ZCPOSV.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NM

                     NM is INTEGER
                     The number of values of N contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix dimension N.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NSMAX)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NSMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NSMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (max(2*NMAX,2*NSMAX+NWORK))

           SWORK

                     SWORK is COMPLEX array, dimension
                                 (NMAX*(NSMAX+NMAX))

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvgb (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NRHS, double precision THRESH, logical TSTERR, complex*16, dimension( * ) A,
       integer LA, complex*16, dimension( * ) AFB, integer LAFB, complex*16, dimension( * ) ASAV,
       complex*16, dimension( * ) B, complex*16, dimension( * ) BSAV, complex*16, dimension( * )
       X, complex*16, dimension( * ) XACT, double precision, dimension( * ) S, complex*16,
       dimension( * ) WORK, double precision, dimension( * ) RWORK, integer, dimension( * )
       IWORK, integer NOUT)
       ZDRVGB ZDRVGBX

       Purpose:

            ZDRVGB tests the driver routines ZGBSV and -SVX.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           A

                     A is COMPLEX*16 array, dimension (LA)

           LA

                     LA is INTEGER
                     The length of the array A.  LA >= (2*NMAX-1)*NMAX
                     where NMAX is the largest entry in NVAL.

           AFB

                     AFB is COMPLEX*16 array, dimension (LAFB)

           LAFB

                     LAFB is INTEGER
                     The length of the array AFB.  LAFB >= (3*NMAX-2)*NMAX
                     where NMAX is the largest entry in NVAL.

           ASAV

                     ASAV is COMPLEX*16 array, dimension (LA)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           BSAV

                     BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           S

                     S is DOUBLE PRECISION array, dimension (2*NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NRHS,NMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (max(NMAX,2*NRHS))

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

       Purpose:

            ZDRVGB tests the driver routines ZGBSV, -SVX, and -SVXX.

            Note that this file is used only when the XBLAS are available,
            otherwise zdrvgb.f defines this subroutine.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           A

                     A is COMPLEX*16 array, dimension (LA)

           LA

                     LA is INTEGER
                     The length of the array A.  LA >= (2*NMAX-1)*NMAX
                     where NMAX is the largest entry in NVAL.

           AFB

                     AFB is COMPLEX*16 array, dimension (LAFB)

           LAFB

                     LAFB is INTEGER
                     The length of the array AFB.  LAFB >= (3*NMAX-2)*NMAX
                     where NMAX is the largest entry in NVAL.

           ASAV

                     ASAV is COMPLEX*16 array, dimension (LA)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           BSAV

                     BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           S

                     S is DOUBLE PRECISION array, dimension (2*NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NRHS,NMAX))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (max(NMAX,2*NRHS))

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvge (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
       dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) ASAV,
       complex*16, dimension( * ) B, complex*16, dimension( * ) BSAV, complex*16, dimension( * )
       X, complex*16, dimension( * ) XACT, double precision, dimension( * ) S, complex*16,
       dimension( * ) WORK, double precision, dimension( * ) RWORK, integer, dimension( * )
       IWORK, integer NOUT)
       ZDRVGE ZDRVGEX

       Purpose:

            ZDRVGE tests the driver routines ZGESV and -SVX.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           ASAV

                     ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           BSAV

                     BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           S

                     S is DOUBLE PRECISION array, dimension (2*NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (2*NRHS+NMAX)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

       Purpose:

            ZDRVGE tests the driver routines ZGESV, -SVX, and -SVXX.

            Note that this file is used only when the XBLAS are available,
            otherwise zdrvge.f defines this subroutine.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           ASAV

                     ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           BSAV

                     BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           S

                     S is DOUBLE PRECISION array, dimension (2*NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (2*NRHS+NMAX)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           April 2012

   subroutine zdrvgt (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NRHS, double precision THRESH, logical TSTERR, complex*16, dimension( * ) A,
       complex*16, dimension( * ) AF, complex*16, dimension( * ) B, complex*16, dimension( * ) X,
       complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
       ZDRVGT

       Purpose:

            ZDRVGT tests ZGTSV and -SVX.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, NRHS >= 0.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           A

                     A is COMPLEX*16 array, dimension (NMAX*4)

           AF

                     AF is COMPLEX*16 array, dimension (NMAX*4)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)

           IWORK

                     IWORK is INTEGER array, dimension (2*NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvhe (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
       dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV,
       complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
       XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
       dimension( * ) IWORK, integer NOUT)
       ZDRVHE ZDRVHEX

       Purpose:

            ZDRVHE tests the driver routines ZHESV and -SVX.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

       Purpose:

            ZDRVHE tests the driver routines ZHESV, -SVX, and -SVXX.

            Note that this file is used only when the XBLAS are available,
            otherwise zdrvhe.f defines this subroutine.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(2,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (2*NMAX+2*NRHS)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           April 2012

   subroutine zdrvhe_rook (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * )
       NVAL, integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
       dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV,
       complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
       XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
       dimension( * ) IWORK, integer NOUT)
       ZDRVHE_ROOK

       Purpose:

            ZDRVHE_ROOK tests the driver routines ZHESV_ROOK.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zdrvhp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
       dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV,
       complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
       XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
       dimension( * ) IWORK, integer NOUT)
       ZDRVHP

       Purpose:

            ZDRVHP tests the driver routines ZHPSV and -SVX.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           AFAC

                     AFAC is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           AINV

                     AINV is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(2,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvls (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
       integer NN, integer, dimension( * ) NVAL, integer NNS, integer, dimension( * ) NSVAL,
       integer NNB, integer, dimension( * ) NBVAL, integer, dimension( * ) NXVAL, double
       precision THRESH, logical TSTERR, complex*16, dimension( * ) A, complex*16, dimension( * )
       COPYA, complex*16, dimension( * ) B, complex*16, dimension( * ) COPYB, complex*16,
       dimension( * ) C, double precision, dimension( * ) S, double precision, dimension( * )
       COPYS, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
       dimension( * ) IWORK, integer NOUT)
       ZDRVLS

       Purpose:

            ZDRVLS tests the least squares driver routines ZGELS, CGELSS, ZGELSY
            and CGELSD.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
                     The matrix of type j is generated as follows:
                     j=1: A = U*D*V where U and V are random unitary matrices
                          and D has random entries (> 0.1) taken from a uniform
                          distribution (0,1). A is full rank.
                     j=2: The same of 1, but A is scaled up.
                     j=3: The same of 1, but A is scaled down.
                     j=4: A = U*D*V where U and V are random unitary matrices
                          and D has 3*min(M,N)/4 random entries (> 0.1) taken
                          from a uniform distribution (0,1) and the remaining
                          entries set to 0. A is rank-deficient.
                     j=5: The same of 4, but A is scaled up.
                     j=6: The same of 5, but A is scaled down.

           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NNB

                     NNB is INTEGER
                     The number of values of NB and NX contained in the
                     vectors NBVAL and NXVAL.  The blocking parameters are used
                     in pairs (NB,NX).

           NBVAL

                     NBVAL is INTEGER array, dimension (NNB)
                     The values of the blocksize NB.

           NXVAL

                     NXVAL is INTEGER array, dimension (NNB)
                     The values of the crossover point NX.

           NNS

                     NNS is INTEGER
                     The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                     The values of the number of right hand sides NRHS.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           A

                     A is COMPLEX*16 array, dimension (MMAX*NMAX)
                     where MMAX is the maximum value of M in MVAL and NMAX is the
                     maximum value of N in NVAL.

           COPYA

                     COPYA is COMPLEX*16 array, dimension (MMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (MMAX*NSMAX)
                     where MMAX is the maximum value of M in MVAL and NSMAX is the
                     maximum value of NRHS in NSVAL.

           COPYB

                     COPYB is COMPLEX*16 array, dimension (MMAX*NSMAX)

           C

                     C is COMPLEX*16 array, dimension (MMAX*NSMAX)

           S

                     S is DOUBLE PRECISION array, dimension
                                 (min(MMAX,NMAX))

           COPYS

                     COPYS is DOUBLE PRECISION array, dimension
                                 (min(MMAX,NMAX))

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (MMAX*NMAX + 4*NMAX + MMAX).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (5*NMAX-1)

           IWORK

                     IWORK is INTEGER array, dimension (15*NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zdrvpb (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
       dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) ASAV,
       complex*16, dimension( * ) B, complex*16, dimension( * ) BSAV, complex*16, dimension( * )
       X, complex*16, dimension( * ) XACT, double precision, dimension( * ) S, complex*16,
       dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
       ZDRVPB

       Purpose:

            ZDRVPB tests the driver routines ZPBSV and -SVX.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           ASAV

                     ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           BSAV

                     BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           S

                     S is DOUBLE PRECISION array, dimension (NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvpo (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
       dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) ASAV,
       complex*16, dimension( * ) B, complex*16, dimension( * ) BSAV, complex*16, dimension( * )
       X, complex*16, dimension( * ) XACT, double precision, dimension( * ) S, complex*16,
       dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
       ZDRVPO ZDRVPOX

       Purpose:

            ZDRVPO tests the driver routines ZPOSV and -SVX.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           ASAV

                     ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           BSAV

                     BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           S

                     S is DOUBLE PRECISION array, dimension (NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

       Purpose:

            ZDRVPO tests the driver routines ZPOSV, -SVX, and -SVXX.

            Note that this file is used only when the XBLAS are available,
            otherwise zdrvpo.f defines this subroutine.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           ASAV

                     ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           BSAV

                     BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           S

                     S is DOUBLE PRECISION array, dimension (NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zdrvpp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
       dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) ASAV,
       complex*16, dimension( * ) B, complex*16, dimension( * ) BSAV, complex*16, dimension( * )
       X, complex*16, dimension( * ) XACT, double precision, dimension( * ) S, complex*16,
       dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
       ZDRVPP

       Purpose:

            ZDRVPP tests the driver routines ZPPSV and -SVX.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)

           ASAV

                     ASAV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           BSAV

                     BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           S

                     S is DOUBLE PRECISION array, dimension (NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvpt (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NRHS, double precision THRESH, logical TSTERR, complex*16, dimension( * ) A,
       double precision, dimension( * ) D, complex*16, dimension( * ) E, complex*16, dimension( *
       ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension(
       * ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
       ZDRVPT

       Purpose:

            ZDRVPT tests ZPTSV and -SVX.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           A

                     A is COMPLEX*16 array, dimension (NMAX*2)

           D

                     D is DOUBLE PRECISION array, dimension (NMAX*2)

           E

                     E is COMPLEX*16 array, dimension (NMAX*2)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(3,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvrf1 (integer NOUT, integer NN, integer, dimension( nn ) NVAL, double precision
       THRESH, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) ARF,
       double precision, dimension( * ) WORK)
       ZDRVRF1

       Purpose:

            ZDRVRF1 tests the LAPACK RFP routines:
                ZLANHF.F

       Parameters:
           NOUT

                     NOUT is INTEGER
                           The unit number for output.

           NN

                     NN is INTEGER
                           The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                           The values of the matrix dimension N.

           THRESH

                     THRESH is DOUBLE PRECISION
                           The threshold value for the test ratios.  A result is
                           included in the output file if RESULT >= THRESH.  To have
                           every test ratio printed, use THRESH = 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,NMAX)

           LDA

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

           ARF

                     ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).

           WORK

                     WORK is DOUBLE PRECISION array, dimension ( NMAX )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvrf2 (integer NOUT, integer NN, integer, dimension( nn ) NVAL, complex*16,
       dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) ARF, complex*16,
       dimension(*) AP, complex*16, dimension( lda, * ) ASAV)
       ZDRVRF2

       Purpose:

            ZDRVRF2 tests the LAPACK RFP convertion routines.

       Parameters:
           NOUT

                     NOUT is INTEGER
                           The unit number for output.

           NN

                     NN is INTEGER
                           The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                           The values of the matrix dimension N.

           A

                     A is COMPLEX*16 array, dimension (LDA,NMAX)

           LDA

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

           ARF

                     ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).

           AP

                     AP is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).

           ASAV

                     ASAV is COMPLEX*16 array, dimension (LDA,NMAX)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvrf3 (integer NOUT, integer NN, integer, dimension( nn ) NVAL, double precision
       THRESH, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) ARF,
       complex*16, dimension( lda, * ) B1, complex*16, dimension( lda, * ) B2, double precision,
       dimension( * ) D_WORK_ZLANGE, complex*16, dimension( * ) Z_WORK_ZGEQRF, complex*16,
       dimension( * ) TAU)
       ZDRVRF3

       Purpose:

            ZDRVRF3 tests the LAPACK RFP routines:
                ZTFSM

       Parameters:
           NOUT

                     NOUT is INTEGER
                           The unit number for output.

           NN

                     NN is INTEGER
                           The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                           The values of the matrix dimension N.

           THRESH

                     THRESH is DOUBLE PRECISION
                           The threshold value for the test ratios.  A result is
                           included in the output file if RESULT >= THRESH.  To have
                           every test ratio printed, use THRESH = 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,NMAX)

           LDA

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

           ARF

                     ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).

           B1

                     B1 is COMPLEX*16 array, dimension (LDA,NMAX)

           B2

                     B2 is COMPLEX*16 array, dimension (LDA,NMAX)

           D_WORK_ZLANGE

                     D_WORK_ZLANGE is DOUBLE PRECISION array, dimension (NMAX)

           Z_WORK_ZGEQRF

                     Z_WORK_ZGEQRF is COMPLEX*16 array, dimension (NMAX)

           TAU

                     TAU is COMPLEX*16 array, dimension (NMAX)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvrf4 (integer NOUT, integer NN, integer, dimension( nn ) NVAL, double precision
       THRESH, complex*16, dimension( ldc, * ) C1, complex*16, dimension( ldc, *) C2, integer
       LDC, complex*16, dimension( * ) CRF, complex*16, dimension( lda, * ) A, integer LDA,
       double precision, dimension( * ) D_WORK_ZLANGE)
       ZDRVRF4

       Purpose:

            ZDRVRF4 tests the LAPACK RFP routines:
                ZHFRK

       Parameters:
           NOUT

                     NOUT is INTEGER
                           The unit number for output.

           NN

                     NN is INTEGER
                           The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                           The values of the matrix dimension N.

           THRESH

                     THRESH is DOUBLE PRECISION
                           The threshold value for the test ratios.  A result is
                           included in the output file if RESULT >= THRESH.  To have
                           every test ratio printed, use THRESH = 0.

           C1

                     C1 is COMPLEX*16 array, dimension (LDC,NMAX)

           C2

                     C2 is COMPLEX*16 array, dimension (LDC,NMAX)

           LDC

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

           CRF

                     CRF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).

           A

                     A is COMPLEX*16 array, dimension (LDA,NMAX)

           LDA

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

           D_WORK_ZLANGE

                     D_WORK_ZLANGE is DOUBLE PRECISION array, dimension (NMAX)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvrfp (integer NOUT, integer NN, integer, dimension( nn ) NVAL, integer NNS,
       integer, dimension( nns ) NSVAL, integer NNT, integer, dimension( nnt ) NTVAL, double
       precision THRESH, complex*16, dimension( * ) A, complex*16, dimension( * ) ASAV,
       complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16, dimension( *
       ) B, complex*16, dimension( * ) BSAV, complex*16, dimension( * ) XACT, complex*16,
       dimension( * ) X, complex*16, dimension( * ) ARF, complex*16, dimension( * ) ARFINV,
       complex*16, dimension( * ) Z_WORK_ZLATMS, complex*16, dimension( * ) Z_WORK_ZPOT02,
       complex*16, dimension( * ) Z_WORK_ZPOT03, double precision, dimension( * ) D_WORK_ZLATMS,
       double precision, dimension( * ) D_WORK_ZLANHE, double precision, dimension( * )
       D_WORK_ZPOT01, double precision, dimension( * ) D_WORK_ZPOT02, double precision,
       dimension( * ) D_WORK_ZPOT03)
       ZDRVRFP

       Purpose:

            ZDRVRFP tests the LAPACK RFP routines:
                ZPFTRF, ZPFTRS, and ZPFTRI.

            This testing routine follow the same tests as ZDRVPO (test for the full
            format Symmetric Positive Definite solver).

            The tests are performed in Full Format, convertion back and forth from
            full format to RFP format are performed using the routines ZTRTTF and
            ZTFTTR.

            First, a specific matrix A of size N is created. There is nine types of
            different matrixes possible.
             1. Diagonal                        6. Random, CNDNUM = sqrt(0.1/EPS)
             2. Random, CNDNUM = 2              7. Random, CNDNUM = 0.1/EPS
            *3. First row and column zero       8. Scaled near underflow
            *4. Last row and column zero        9. Scaled near overflow
            *5. Middle row and column zero
            (* - tests error exits from ZPFTRF, no test ratios are computed)
            A solution XACT of size N-by-NRHS is created and the associated right
            hand side B as well. Then ZPFTRF is called to compute L (or U), the
            Cholesky factor of A. Then L (or U) is used to solve the linear system
            of equations AX = B. This gives X. Then L (or U) is used to compute the
            inverse of A, AINV. The following four tests are then performed:
            (1) norm( L*L' - A ) / ( N * norm(A) * EPS ) or
                norm( U'*U - A ) / ( N * norm(A) * EPS ),
            (2) norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
            (3) norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ),
            (4) ( norm(X-XACT) * RCOND ) / ( norm(XACT) * EPS ),
            where EPS is the machine precision, RCOND the condition number of A, and
            norm( . ) the 1-norm for (1,2,3) and the inf-norm for (4).
            Errors occur when INFO parameter is not as expected. Failures occur when
            a test ratios is greater than THRES.

       Parameters:
           NOUT

                     NOUT is INTEGER
                           The unit number for output.

           NN

                     NN is INTEGER
                           The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                           The values of the matrix dimension N.

           NNS

                     NNS is INTEGER
                           The number of values of NRHS contained in the vector NSVAL.

           NSVAL

                     NSVAL is INTEGER array, dimension (NNS)
                           The values of the number of right-hand sides NRHS.

           NNT

                     NNT is INTEGER
                           The number of values of MATRIX TYPE contained in the vector NTVAL.

           NTVAL

                     NTVAL is INTEGER array, dimension (NNT)
                           The values of matrix type (between 0 and 9 for PO/PP/PF matrices).

           THRESH

                     THRESH is DOUBLE PRECISION
                           The threshold value for the test ratios.  A result is
                           included in the output file if RESULT >= THRESH.  To have
                           every test ratio printed, use THRESH = 0.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           ASAV

                     ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*MAXRHS)

           BSAV

                     BSAV is COMPLEX*16 array, dimension (NMAX*MAXRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*MAXRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*MAXRHS)

           ARF

                     ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2)

           ARFINV

                     ARFINV is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2)

           Z_WORK_ZLATMS

                     Z_WORK_ZLATMS is COMPLEX*16 array, dimension ( 3*NMAX )

           Z_WORK_ZPOT02

                     Z_WORK_ZPOT02 is COMPLEX*16 array, dimension ( NMAX*MAXRHS )

           Z_WORK_ZPOT03

                     Z_WORK_ZPOT03 is COMPLEX*16 array, dimension ( NMAX*NMAX )

           D_WORK_ZLATMS

                     D_WORK_ZLATMS is DOUBLE PRECISION array, dimension ( NMAX )

           D_WORK_ZLANHE

                     D_WORK_ZLANHE is DOUBLE PRECISION array, dimension ( NMAX )

           D_WORK_ZPOT01

                     D_WORK_ZPOT01 is DOUBLE PRECISION array, dimension ( NMAX )

           D_WORK_ZPOT02

                     D_WORK_ZPOT02 is DOUBLE PRECISION array, dimension ( NMAX )

           D_WORK_ZPOT03

                     D_WORK_ZPOT03 is DOUBLE PRECISION array, dimension ( NMAX )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zdrvsp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
       dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV,
       complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
       XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
       dimension( * ) IWORK, integer NOUT)
       ZDRVSP

       Purpose:

            ZDRVSP tests the driver routines ZSPSV and -SVX.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           AFAC

                     AFAC is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           AINV

                     AINV is COMPLEX*16 array, dimension
                                 (NMAX*(NMAX+1)/2)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(2,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvsy (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
       integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
       dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV,
       complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
       XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
       dimension( * ) IWORK, integer NOUT)
       ZDRVSY ZDRVSYX

       Purpose:

            ZDRVSY tests the driver routines ZSYSV and -SVX.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

       Purpose:

            ZDRVSY tests the driver routines ZSYSV, -SVX, and -SVXX.

            Note that this file is used only when the XBLAS are available,
            otherwise zdrvsy.f defines this subroutine.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           WORK

                     WORK is COMPLEX*16 array, dimension
                                 (NMAX*max(2,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (2*NMAX+2*NRHS)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           April 2012

   subroutine zdrvsy_rook (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * )
       NVAL, integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
       dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV,
       complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
       XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
       dimension( * ) IWORK, integer NOUT)
       ZDRVSY_ROOK

       Purpose:

            ZDRVSY_ROOK tests the driver routines ZSYSV_ROOK.

       Parameters:
           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     The matrix types to be used for testing.  Matrices of type j
                     (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
                     .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix dimension N.

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors to be generated for
                     each linear system.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for N, used in dimensioning the
                     work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AFAC

                     AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)

           AINV

                     AINV is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NRHS)

           X

                     X is COMPLEX*16 array, dimension (NMAX*NRHS)

           XACT

                     XACT is COMPLEX*16 array, dimension (NMAX*NRHS)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zebchvxx (double precision THRESH, character*3 PATH)
       ZEBCHVXX Purpose:

         ZEBCHVXX will run Z**SVXX on a series of Hilbert matrices and then
         compare the error bounds returned by Z**SVXX to see if the returned
         answer indeed falls within those bounds.

         Eight test ratios will be computed.  The tests will pass if they are .LT.
         THRESH.  There are two cases that are determined by 1 / (SQRT( N ) * EPS).
         If that value is .LE. to the component wise reciprocal condition number,
         it uses the guaranteed case, other wise it uses the unguaranteed case.

         Test ratios:
            Let Xc be X_computed and Xt be X_truth.
            The norm used is the infinity norm.

            Let A be the guaranteed case and B be the unguaranteed case.

              1. Normwise guaranteed forward error bound.
              A: norm ( abs( Xc - Xt ) / norm ( Xt ) .LE. ERRBND( *, nwise_i, bnd_i ) and
                 ERRBND( *, nwise_i, bnd_i ) .LE. MAX(SQRT(N),10) * EPS.
                 If these conditions are met, the test ratio is set to be
                 ERRBND( *, nwise_i, bnd_i ) / MAX(SQRT(N), 10).  Otherwise it is 1/EPS.
              B: For this case, CGESVXX should just return 1.  If it is less than
                 one, treat it the same as in 1A.  Otherwise it fails. (Set test
                 ratio to ERRBND( *, nwise_i, bnd_i ) * THRESH?)

              2. Componentwise guaranteed forward error bound.
              A: norm ( abs( Xc(j) - Xt(j) ) ) / norm (Xt(j)) .LE. ERRBND( *, cwise_i, bnd_i )
                 for all j .AND. ERRBND( *, cwise_i, bnd_i ) .LE. MAX(SQRT(N), 10) * EPS.
                 If these conditions are met, the test ratio is set to be
                 ERRBND( *, cwise_i, bnd_i ) / MAX(SQRT(N), 10).  Otherwise it is 1/EPS.
              B: Same as normwise test ratio.

              3. Backwards error.
              A: The test ratio is set to BERR/EPS.
              B: Same test ratio.

              4. Reciprocal condition number.
              A: A condition number is computed with Xt and compared with the one
                 returned from CGESVXX.  Let RCONDc be the RCOND returned by CGESVXX
                 and RCONDt be the RCOND from the truth value.  Test ratio is set to
                 MAX(RCONDc/RCONDt, RCONDt/RCONDc).
              B: Test ratio is set to 1 / (EPS * RCONDc).

              5. Reciprocal normwise condition number.
              A: The test ratio is set to
                 MAX(ERRBND( *, nwise_i, cond_i ) / NCOND, NCOND / ERRBND( *, nwise_i, cond_i )).
              B: Test ratio is set to 1 / (EPS * ERRBND( *, nwise_i, cond_i )).

              6. Reciprocal componentwise condition number.
              A: Test ratio is set to
                 MAX(ERRBND( *, cwise_i, cond_i ) / CCOND, CCOND / ERRBND( *, cwise_i, cond_i )).
              B: Test ratio is set to 1 / (EPS * ERRBND( *, cwise_i, cond_i )).

            .. Parameters ..
            NMAX is determined by the largest number in the inverse of the hilbert
            matrix.  Precision is exhausted when the largest entry in it is greater
            than 2 to the power of the number of bits in the fraction of the data
            type used plus one, which is 24 for single precision.
            NMAX should be 6 for single and 11 for double.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrab (integer NUNIT)
       ZERRAB

       Purpose:

            DERRAB tests the error exits for ZCGESV.

       Parameters:
           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrac (integer NUNIT)
       ZERRAC

       Purpose:

            ZERRPX tests the error exits for ZCPOSV.

       Parameters:
           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrge (character*3 PATH, integer NUNIT)
       ZERRGE ZERRGEX

       Purpose:

            ZERRGE tests the error exits for the COMPLEX*16 routines
            for general matrices.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

       Purpose:

            ZERRGE tests the error exits for the COMPLEX*16 routines
            for general matrices.

            Note that this file is used only when the XBLAS are available,
            otherwise zerrge.f defines this subroutine.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrgt (character*3 PATH, integer NUNIT)
       ZERRGT

       Purpose:

            ZERRGT tests the error exits for the COMPLEX*16 tridiagonal
            routines.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrhe (character*3 PATH, integer NUNIT)
       ZERRHE ZERRHEX

       Purpose:

            ZERRHE tests the error exits for the COMPLEX*16 routines
            for Hermitian indefinite matrices.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

       Purpose:

            ZERRHE tests the error exits for the COMPLEX*16 routines
            for Hermitian indefinite matrices.

            Note that this file is used only when the XBLAS are available,
            otherwise zerrhe.f defines this subroutine.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zerrlq (character*3 PATH, integer NUNIT)
       ZERRLQ

       Purpose:

            ZERRLQ tests the error exits for the COMPLEX*16 routines
            that use the LQ decomposition of a general matrix.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrls (character*3 PATH, integer NUNIT)
       ZERRLS

       Purpose:

            ZERRLS tests the error exits for the COMPLEX*16 least squares
            driver routines (ZGELS, CGELSS, CGELSY, CGELSD).

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zerrpo (character*3 PATH, integer NUNIT)
       ZERRPO ZERRPOX

       Purpose:

            ZERRPO tests the error exits for the COMPLEX*16 routines
            for Hermitian positive definite matrices.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

       Purpose:

            ZERRPO tests the error exits for the COMPLEX*16 routines
            for Hermitian positive definite matrices.

            Note that this file is used only when the XBLAS are available,
            otherwise zerrpo.f defines this subroutine.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zerrps (character*3 PATH, integer NUNIT)
       ZERRPS

       Purpose:

            ZERRPS tests the error exits for the COMPLEX routines
            for ZPSTRF.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrql (character*3 PATH, integer NUNIT)
       ZERRQL

       Purpose:

            ZERRQL tests the error exits for the COMPLEX*16 routines
            that use the QL decomposition of a general matrix.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrqp (character*3 PATH, integer NUNIT)
       ZERRQP

       Purpose:

            ZERRQP tests the error exits for ZGEQP3.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zerrqr (character*3 PATH, integer NUNIT)
       ZERRQR

       Purpose:

            ZERRQR tests the error exits for the COMPLEX*16 routines
            that use the QR decomposition of a general matrix.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrqrt (character*3 PATH, integer NUNIT)
       ZERRQRT

       Purpose:

            ZERRQRT tests the error exits for the COMPLEX*16 routines
            that use the QRT decomposition of a general matrix.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrqrtp (character*3 PATH, integer NUNIT)
       ZERRQRTP

       Purpose:

            ZERRQRTP tests the error exits for the COMPLEX*16 routines
            that use the QRT decomposition of a triangular-pentagonal matrix.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrrfp (integer NUNIT)
       ZERRRFP

       Purpose:

            ZERRRFP tests the error exits for the COMPLEX*16 driver routines
            for solving linear systems of equations.

            ZDRVRFP tests the COMPLEX*16 LAPACK RFP routines:
                ZTFSM, ZTFTRI, ZHFRK, ZTFTTP, ZTFTTR, ZPFTRF, ZPFTRS, ZTPTTF,
                ZTPTTR, ZTRTTF, and ZTRTTP

       Parameters:
           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrrq (character*3 PATH, integer NUNIT)
       ZERRRQ

       Purpose:

            ZERRRQ tests the error exits for the COMPLEX*16 routines
            that use the RQ decomposition of a general matrix.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrsy (character*3 PATH, integer NUNIT)
       ZERRSY ZERRSYX

       Purpose:

            ZERRSY tests the error exits for the COMPLEX*16 routines
            for symmetric indefinite matrices.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

       Purpose:

            ZERRSY tests the error exits for the COMPLEX*16 routines
            for symmetric indefinite matrices.

            Note that this file is used only when the XBLAS are available,
            otherwise zerrsy.f defines this subroutine.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zerrtr (character*3 PATH, integer NUNIT)
       ZERRTR

       Purpose:

            ZERRTR tests the error exits for the COMPLEX*16 triangular routines.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrtz (character*3 PATH, integer NUNIT)
       ZERRTZ

       Purpose:

            ZERRTZ tests the error exits for ZTZRZF.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zerrvx (character*3 PATH, integer NUNIT)
       ZERRVX ZERRVXX

       Purpose:

            ZERRVX tests the error exits for the COMPLEX*16 driver routines
            for solving linear systems of equations.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

       Purpose:

            ZERRVX tests the error exits for the COMPLEX*16 driver routines
            for solving linear systems of equations.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zgbt01 (integer M, integer N, integer KL, integer KU, complex*16, dimension( lda, *
       ) A, integer LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer,
       dimension( * ) IPIV, complex*16, dimension( * ) WORK, double precision RESID)
       ZGBT01

       Purpose:

            ZGBT01 reconstructs a band matrix  A  from its L*U factorization and
            computes the residual:
               norm(L*U - A) / ( N * norm(A) * EPS ),
            where EPS is the machine epsilon.

            The expression L*U - A is computed one column at a time, so A and
            AFAC are not modified.

       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.

           KL

                     KL is INTEGER
                     The number of subdiagonals within the band of A.  KL >= 0.

           KU

                     KU is INTEGER
                     The number of superdiagonals within the band of A.  KU >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original matrix A in band storage, stored in rows 1 to
                     KL+KU+1.

           LDA

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

           AFAC

                     AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
                     The factored form of the matrix A.  AFAC contains the banded
                     factors L and U from the L*U factorization, as computed by
                     ZGBTRF.  U is stored as an upper triangular band matrix with
                     KL+KU superdiagonals in rows 1 to KL+KU+1, and the
                     multipliers used during the factorization are stored in rows
                     KL+KU+2 to 2*KL+KU+1.  See ZGBTRF for further details.

           LDAFAC

                     LDAFAC is INTEGER
                     The leading dimension of the array AFAC.
                     LDAFAC >= max(1,2*KL*KU+1).

           IPIV

                     IPIV is INTEGER array, dimension (min(M,N))
                     The pivot indices from ZGBTRF.

           WORK

                     WORK is COMPLEX*16 array, dimension (2*KL+KU+1)

           RESID

                     RESID is DOUBLE PRECISION
                     norm(L*U - A) / ( N * norm(A) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zgbt02 (character TRANS, integer M, integer N, integer KL, integer KU, integer
       NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X,
       integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision RESID)
       ZGBT02

       Purpose:

            ZGBT02 computes the residual for a solution of a banded system of
            equations  A*x = b  or  A'*x = b:
               RESID = norm( B - A*X ) / ( norm(A) * norm(X) * EPS).
            where EPS is the machine precision.

       Parameters:
           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations:
                     = 'N':  A *x = b
                     = 'T':  A'*x = b, where A' is the transpose of A
                     = 'C':  A'*x = b, where A' is the transpose of A

           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.

           KL

                     KL is INTEGER
                     The number of subdiagonals within the band of A.  KL >= 0.

           KU

                     KU is INTEGER
                     The number of superdiagonals within the band of A.  KU >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of columns of B.  NRHS >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original matrix A in band storage, stored in rows 1 to
                     KL+KU+1.

           LDA

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  If TRANS = 'N',
                     LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the right hand side vectors for the system of
                     linear equations.
                     On exit, B is overwritten with the difference B - A*X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  IF TRANS = 'N',
                     LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zgbt05 (character TRANS, integer N, integer KL, integer KU, integer NRHS,
       complex*16, dimension( ldab, * ) AB, integer LDAB, complex*16, dimension( ldb, * ) B,
       integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension(
       ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision,
       dimension( * ) BERR, double precision, dimension( * ) RESLTS)
       ZGBT05

       Purpose:

            ZGBT05 tests the error bounds from iterative refinement for the
            computed solution to a system of equations op(A)*X = B, where A is a
            general band matrix of order n with kl subdiagonals and ku
            superdiagonals and op(A) = A or A**T, depending on TRANS.

            RESLTS(1) = test of the error bound
                      = norm(X - XACT) / ( norm(X) * FERR )

            A large value is returned if this ratio is not less than one.

            RESLTS(2) = residual from the iterative refinement routine
                      = the maximum of BERR / ( NZ*EPS + (*) ), where
                        (*) = NZ*UNFL / (min_i (abs(op(A))*abs(X) +abs(b))_i )
                        and NZ = max. number of nonzeros in any row of A, plus 1

       Parameters:
           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 = Transpose)

           N

                     N is INTEGER
                     The number of rows of the matrices X, B, and XACT, and the
                     order of the matrix A.  N >= 0.

           KL

                     KL is INTEGER
                     The number of subdiagonals within the band of A.  KL >= 0.

           KU

                     KU is INTEGER
                     The number of superdiagonals within the band of A.  KU >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of columns of the matrices X, B, and XACT.
                     NRHS >= 0.

           AB

                     AB is COMPLEX*16 array, dimension (LDAB,N)
                     The original band matrix A, stored in rows 1 to KL+KU+1.
                     The j-th column of A is stored in the j-th column of the
                     array AB as follows:
                     AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl).

           LDAB

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors.  Each vector is stored as a
                     column of the matrix X.

           LDX

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

           XACT

                     XACT is COMPLEX*16 array, dimension (LDX,NRHS)
                     The exact solution vectors.  Each vector is stored as a
                     column of the matrix XACT.

           LDXACT

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

           FERR

                     FERR is DOUBLE PRECISION array, dimension (NRHS)
                     The estimated forward error bounds for each solution vector
                     X.  If XTRUE is the true solution, FERR bounds the magnitude
                     of the largest entry in (X - XTRUE) divided by the magnitude
                     of the largest entry in X.

           BERR

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

           RESLTS

                     RESLTS is DOUBLE PRECISION array, dimension (2)
                     The maximum over the NRHS solution vectors of the ratios:
                     RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
                     RESLTS(2) = BERR / ( NZ*EPS + (*) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zgelqs (integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( ldb, * ) B, integer
       LDB, complex*16, dimension( lwork ) WORK, integer LWORK, integer INFO)
       ZGELQS

       Purpose:

            Compute a minimum-norm solution
                min || A*X - B ||
            using the LQ factorization
                A = L*Q
            computed by ZGELQF.

       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 >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of columns of B.  NRHS >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     Details of the LQ factorization of the original matrix A as
                     returned by ZGELQF.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= M.

           TAU

                     TAU is COMPLEX*16 array, dimension (M)
                     Details of the orthogonal matrix Q.

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the m-by-nrhs right hand side matrix B.
                     On exit, the n-by-nrhs solution matrix X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B. LDB >= N.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of the array WORK.  LWORK must be at least NRHS,
                     and should be at least NRHS*NB, where NB is the block size
                     for this environment.

           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.

       Date:
           November 2011

   logical function zgennd (integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA)
       ZGENND

       Purpose:

               ZGENND tests that its argument has a real, non-negative diagonal.

       Parameters:
           M

                     M is INTEGER
                     The number of rows in A.

           N

                     N is INTEGER
                     The number of columns in A.

           A

                     A is COMPLEX*16 array, dimension (LDA, N)
                     The matrix.

           LDA

                     LDA is INTEGER
                     Leading dimension of A.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zgeqls (integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( ldb, * ) B, integer
       LDB, complex*16, dimension( lwork ) WORK, integer LWORK, integer INFO)
       ZGEQLS

       Purpose:

            Solve the least squares problem
                min || A*X - B ||
            using the QL factorization
                A = Q*L
            computed by ZGEQLF.

       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.

           NRHS

                     NRHS is INTEGER
                     The number of columns of B.  NRHS >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     Details of the QL factorization of the original matrix A as
                     returned by ZGEQLF.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= M.

           TAU

                     TAU is COMPLEX*16 array, dimension (N)
                     Details of the orthogonal matrix Q.

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the m-by-nrhs right hand side matrix B.
                     On exit, the n-by-nrhs solution matrix X, stored in rows
                     m-n+1:m.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B. LDB >= M.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of the array WORK.  LWORK must be at least NRHS,
                     and should be at least NRHS*NB, where NB is the block size
                     for this environment.

           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.

       Date:
           November 2011

   subroutine zgeqrs (integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( ldb, * ) B, integer
       LDB, complex*16, dimension( lwork ) WORK, integer LWORK, integer INFO)
       ZGEQRS

       Purpose:

            Solve the least squares problem
                min || A*X - B ||
            using the QR factorization
                A = Q*R
            computed by ZGEQRF.

       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.

           NRHS

                     NRHS is INTEGER
                     The number of columns of B.  NRHS >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     Details of the QR factorization of the original matrix A as
                     returned by ZGEQRF.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= M.

           TAU

                     TAU is COMPLEX*16 array, dimension (N)
                     Details of the orthogonal matrix Q.

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the m-by-nrhs right hand side matrix B.
                     On exit, the n-by-nrhs solution matrix X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B. LDB >= M.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of the array WORK.  LWORK must be at least NRHS,
                     and should be at least NRHS*NB, where NB is the block size
                     for this environment.

           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.

       Date:
           November 2011

   subroutine zgerqs (integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( ldb, * ) B, integer
       LDB, complex*16, dimension( lwork ) WORK, integer LWORK, integer INFO)
       ZGERQS

       Purpose:

            Compute a minimum-norm solution
                min || A*X - B ||
            using the RQ factorization
                A = R*Q
            computed by ZGERQF.

       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 >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of columns of B.  NRHS >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     Details of the RQ factorization of the original matrix A as
                     returned by ZGERQF.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= M.

           TAU

                     TAU is COMPLEX*16 array, dimension (M)
                     Details of the orthogonal matrix Q.

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the right hand side vectors for the linear system.
                     On exit, the solution vectors X.  Each solution vector
                     is contained in rows 1:N of a column of B.

           LDB

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

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of the array WORK.  LWORK must be at least NRHS,
                     and should be at least NRHS*NB, where NB is the block size
                     for this environment.

           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.

       Date:
           November 2011

   subroutine zget01 (integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA,
       complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * ) IPIV,
       double precision, dimension( * ) RWORK, double precision RESID)
       ZGET01

       Purpose:

            ZGET01 reconstructs a matrix A from its L*U factorization and
            computes the residual
               norm(L*U - A) / ( N * norm(A) * EPS ),
            where EPS is the machine epsilon.

       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.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original M x N matrix A.

           LDA

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

           AFAC

                     AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
                     The factored form of the matrix A.  AFAC contains the factors
                     L and U from the L*U factorization as computed by ZGETRF.
                     Overwritten with the reconstructed matrix, and then with the
                     difference L*U - A.

           LDAFAC

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

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     The pivot indices from ZGETRF.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESID

                     RESID is DOUBLE PRECISION
                     norm(L*U - A) / ( N * norm(A) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget02 (character TRANS, integer M, integer N, integer NRHS, complex*16, dimension(
       lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
       dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double
       precision RESID)
       ZGET02

       Purpose:

            ZGET02 computes the residual for a solution of a system of linear
            equations  A*x = b  or  A'*x = b:
               RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
            where EPS is the machine epsilon.

       Parameters:
           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations:
                     = 'N':  A *x = b
                     = 'T':  A^T*x = b, where A^T is the transpose of A
                     = 'C':  A^H*x = b, where A^H is the conjugate transpose of A

           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.

           NRHS

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

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original M x N matrix A.

           LDA

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  If TRANS = 'N',
                     LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the right hand side vectors for the system of
                     linear equations.
                     On exit, B is overwritten with the difference B - A*X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  IF TRANS = 'N',
                     LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zget03 (integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16,
       dimension( ldainv, * ) AINV, integer LDAINV, complex*16, dimension( ldwork, * ) WORK,
       integer LDWORK, double precision, dimension( * ) RWORK, double precision RCOND, double
       precision RESID)
       ZGET03

       Purpose:

            ZGET03 computes the residual for a general matrix times its inverse:
               norm( I - AINV*A ) / ( N * norm(A) * norm(AINV) * EPS ),
            where EPS is the machine epsilon.

       Parameters:
           N

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

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original N x N matrix A.

           LDA

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

           AINV

                     AINV is COMPLEX*16 array, dimension (LDAINV,N)
                     The inverse of the matrix A.

           LDAINV

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

           WORK

                     WORK is COMPLEX*16 array, dimension (LDWORK,N)

           LDWORK

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RCOND

                     RCOND is DOUBLE PRECISION
                     The reciprocal of the condition number of A, computed as
                     ( 1/norm(A) ) / norm(AINV).

           RESID

                     RESID is DOUBLE PRECISION
                     norm(I - AINV*A) / ( N * norm(A) * norm(AINV) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget04 (integer N, integer NRHS, complex*16, dimension( ldx, * ) X, integer LDX,
       complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision RCOND, double
       precision RESID)
       ZGET04

       Purpose:

            ZGET04 computes the difference between a computed solution and the
            true solution to a system of linear equations.

            RESID =  ( norm(X-XACT) * RCOND ) / ( norm(XACT) * EPS ),
            where RCOND is the reciprocal of the condition number and EPS is the
            machine epsilon.

       Parameters:
           N

                     N is INTEGER
                     The number of rows of the matrices X and XACT.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of columns of the matrices X and XACT.  NRHS >= 0.

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors.  Each vector is stored as a
                     column of the matrix X.

           LDX

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

           XACT

                     XACT is COMPLEX*16 array, dimension (LDX,NRHS)
                     The exact solution vectors.  Each vector is stored as a
                     column of the matrix XACT.

           LDXACT

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

           RCOND

                     RCOND is DOUBLE PRECISION
                     The reciprocal of the condition number of the coefficient
                     matrix in the system of equations.

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the NRHS solution vectors of
                     ( norm(X-XACT) * RCOND ) / ( norm(XACT) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget07 (character TRANS, integer N, integer NRHS, complex*16, dimension( lda, * )
       A, integer LDA, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension(
       ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double
       precision, dimension( * ) FERR, logical CHKFERR, double precision, dimension( * ) BERR,
       double precision, dimension( * ) RESLTS)
       ZGET07

       Purpose:

            ZGET07 tests the error bounds from iterative refinement for the
            computed solution to a system of equations op(A)*X = B, where A is a
            general n by n matrix and op(A) = A or A**T, depending on TRANS.

            RESLTS(1) = test of the error bound
                      = norm(X - XACT) / ( norm(X) * FERR )

            A large value is returned if this ratio is not less than one.

            RESLTS(2) = residual from the iterative refinement routine
                      = the maximum of BERR / ( (n+1)*EPS + (*) ), where
                        (*) = (n+1)*UNFL / (min_i (abs(op(A))*abs(X) +abs(b))_i )

       Parameters:
           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 = Transpose)

           N

                     N is INTEGER
                     The number of rows of the matrices X and XACT.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of columns of the matrices X and XACT.  NRHS >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original n by n matrix A.

           LDA

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors.  Each vector is stored as a
                     column of the matrix X.

           LDX

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

           XACT

                     XACT is COMPLEX*16 array, dimension (LDX,NRHS)
                     The exact solution vectors.  Each vector is stored as a
                     column of the matrix XACT.

           LDXACT

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

           FERR

                     FERR is DOUBLE PRECISION array, dimension (NRHS)
                     The estimated forward error bounds for each solution vector
                     X.  If XTRUE is the true solution, FERR bounds the magnitude
                     of the largest entry in (X - XTRUE) divided by the magnitude
                     of the largest entry in X.

           CHKFERR

                     CHKFERR is LOGICAL
                     Set to .TRUE. to check FERR, .FALSE. not to check FERR.
                     When the test system is ill-conditioned, the "true"
                     solution in XACT may be incorrect.

           BERR

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

           RESLTS

                     RESLTS is DOUBLE PRECISION array, dimension (2)
                     The maximum over the NRHS solution vectors of the ratios:
                     RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
                     RESLTS(2) = BERR / ( (n+1)*EPS + (*) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget08 (character TRANS, integer M, integer N, integer NRHS, complex*16, dimension(
       lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
       dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double
       precision RESID)
       ZGET08

       Purpose:

            ZGET08 computes the residual for a solution of a system of linear
            equations  A*x = b  or  A'*x = b:
               RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
            where EPS is the machine epsilon.

       Parameters:
           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations:
                     = 'N':  A *x = b
                     = 'T':  A^T*x = b, where A^T is the transpose of A
                     = 'C':  A^H*x = b, where A^H is the conjugate transpose of A

           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.

           NRHS

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

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original M x N matrix A.

           LDA

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  If TRANS = 'N',
                     LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the right hand side vectors for the system of
                     linear equations.
                     On exit, B is overwritten with the difference B - A*X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  IF TRANS = 'N',
                     LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zgtt01 (integer N, complex*16, dimension( * ) DL, complex*16, dimension( * ) D,
       complex*16, dimension( * ) DU, complex*16, dimension( * ) DLF, complex*16, dimension( * )
       DF, complex*16, dimension( * ) DUF, complex*16, dimension( * ) DU2, integer, dimension( *
       ) IPIV, complex*16, dimension( ldwork, * ) WORK, integer LDWORK, double precision,
       dimension( * ) RWORK, double precision RESID)
       ZGTT01

       Purpose:

            ZGTT01 reconstructs a tridiagonal matrix A from its LU factorization
            and computes the residual
               norm(L*U - A) / ( norm(A) * EPS ),
            where EPS is the machine epsilon.

       Parameters:
           N

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

           DL

                     DL is COMPLEX*16 array, dimension (N-1)
                     The (n-1) sub-diagonal elements of A.

           D

                     D is COMPLEX*16 array, dimension (N)
                     The diagonal elements of A.

           DU

                     DU is COMPLEX*16 array, dimension (N-1)
                     The (n-1) super-diagonal elements of A.

           DLF

                     DLF is COMPLEX*16 array, dimension (N-1)
                     The (n-1) multipliers that define the matrix L from the
                     LU factorization of A.

           DF

                     DF is COMPLEX*16 array, dimension (N)
                     The n diagonal elements of the upper triangular matrix U from
                     the LU factorization of A.

           DUF

                     DUF is COMPLEX*16 array, dimension (N-1)
                     The (n-1) elements of the first super-diagonal of U.

           DU2

                     DU2 is COMPLEX*16 array, dimension (N-2)
                     The (n-2) elements of the second super-diagonal of U.

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     The pivot indices; for 1 <= i <= n, row i of the matrix was
                     interchanged with row IPIV(i).  IPIV(i) will always be either
                     i or i+1; IPIV(i) = i indicates a row interchange was not
                     required.

           WORK

                     WORK is COMPLEX*16 array, dimension (LDWORK,N)

           LDWORK

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     The scaled residual:  norm(L*U - A) / (norm(A) * EPS)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zgtt02 (character TRANS, integer N, integer NRHS, complex*16, dimension( * ) DL,
       complex*16, dimension( * ) D, complex*16, dimension( * ) DU, complex*16, dimension( ldx, *
       ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision RESID)
       ZGTT02

       Purpose:

            ZGTT02 computes the residual for the solution to a tridiagonal
            system of equations:
               RESID = norm(B - op(A)*X) / (norm(A) * norm(X) * EPS),
            where EPS is the machine epsilon.

       Parameters:
           TRANS

                     TRANS is CHARACTER
                     Specifies the form of the residual.
                     = 'N':  B - A * X     (No transpose)
                     = 'T':  B - A**T * X  (Transpose)
                     = 'C':  B - A**H * X  (Conjugate transpose)

           N

                     N is INTEGTER
                     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.

           DL

                     DL is COMPLEX*16 array, dimension (N-1)
                     The (n-1) sub-diagonal elements of A.

           D

                     D is COMPLEX*16 array, dimension (N)
                     The diagonal elements of A.

           DU

                     DU is COMPLEX*16 array, dimension (N-1)
                     The (n-1) super-diagonal elements of A.

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors X.

           LDX

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the right hand side vectors for the system of
                     linear equations.
                     On exit, B is overwritten with the difference B - op(A)*X.

           LDB

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

           RESID

                     RESID is DOUBLE PRECISION
                     norm(B - op(A)*X) / (norm(A) * norm(X) * EPS)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zgtt05 (character TRANS, integer N, integer NRHS, complex*16, dimension( * ) DL,
       complex*16, dimension( * ) D, complex*16, dimension( * ) DU, complex*16, dimension( ldb, *
       ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension(
       ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision,
       dimension( * ) BERR, double precision, dimension( * ) RESLTS)
       ZGTT05

       Purpose:

            ZGTT05 tests the error bounds from iterative refinement for the
            computed solution to a system of equations A*X = B, where A is a
            general tridiagonal matrix of order n and op(A) = A or A**T,
            depending on TRANS.

            RESLTS(1) = test of the error bound
                      = norm(X - XACT) / ( norm(X) * FERR )

            A large value is returned if this ratio is not less than one.

            RESLTS(2) = residual from the iterative refinement routine
                      = the maximum of BERR / ( NZ*EPS + (*) ), where
                        (*) = NZ*UNFL / (min_i (abs(op(A))*abs(X) +abs(b))_i )
                        and NZ = max. number of nonzeros in any row of A, plus 1

       Parameters:
           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 = Transpose)

           N

                     N is INTEGER
                     The number of rows of the matrices X and XACT.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of columns of the matrices X and XACT.  NRHS >= 0.

           DL

                     DL is COMPLEX*16 array, dimension (N-1)
                     The (n-1) sub-diagonal elements of A.

           D

                     D is COMPLEX*16 array, dimension (N)
                     The diagonal elements of A.

           DU

                     DU is COMPLEX*16 array, dimension (N-1)
                     The (n-1) super-diagonal elements of A.

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors.  Each vector is stored as a
                     column of the matrix X.

           LDX

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

           XACT

                     XACT is COMPLEX*16 array, dimension (LDX,NRHS)
                     The exact solution vectors.  Each vector is stored as a
                     column of the matrix XACT.

           LDXACT

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

           FERR

                     FERR is DOUBLE PRECISION array, dimension (NRHS)
                     The estimated forward error bounds for each solution vector
                     X.  If XTRUE is the true solution, FERR bounds the magnitude
                     of the largest entry in (X - XTRUE) divided by the magnitude
                     of the largest entry in X.

           BERR

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

           RESLTS

                     RESLTS is DOUBLE PRECISION array, dimension (2)
                     The maximum over the NRHS solution vectors of the ratios:
                     RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
                     RESLTS(2) = BERR / ( NZ*EPS + (*) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zhet01 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA,
       complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * ) IPIV,
       complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) RWORK,
       double precision RESID)
       ZHET01

       Purpose:

            ZHET01 reconstructs a Hermitian indefinite matrix A from its
            block L*D*L' or U*D*U' factorization and computes the residual
               norm( C - A ) / ( N * norm(A) * EPS ),
            where C is the reconstructed matrix, EPS is the machine epsilon,
            L' is the conjugate transpose of L, and U' is the conjugate transpose
            of U.

       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 number of rows and columns of the matrix A.  N >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original Hermitian matrix A.

           LDA

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

           AFAC

                     AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
                     The factored form of the matrix A.  AFAC contains the block
                     diagonal matrix D and the multipliers used to obtain the
                     factor L or U from the block L*D*L' or U*D*U' factorization
                     as computed by ZHETRF.

           LDAFAC

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

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     The pivot indices from ZHETRF.

           C

                     C is COMPLEX*16 array, dimension (LDC,N)

           LDC

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
                     If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zhet01_rook (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer
       LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * )
       IPIV, complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * )
       RWORK, double precision RESID)
       ZHET01_ROOK

       Purpose:

            ZHET01_ROOK reconstructs a complex Hermitian indefinite matrix A from its
            block L*D*L' or U*D*U' factorization and computes the residual
               norm( C - A ) / ( N * norm(A) * EPS ),
            where C is the reconstructed matrix, EPS is the machine epsilon,
            L' is the transpose of L, and U' is the transpose of U.

       Parameters:
           UPLO

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

           N

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

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original complex Hermitian matrix A.

           LDA

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

           AFAC

                     AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
                     The factored form of the matrix A.  AFAC contains the block
                     diagonal matrix D and the multipliers used to obtain the
                     factor L or U from the block L*D*L' or U*D*U' factorization
                     as computed by CSYTRF_ROOK.

           LDAFAC

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

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     The pivot indices from CSYTRF_ROOK.

           C

                     C is COMPLEX*16 array, dimension (LDC,N)

           LDC

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
                     If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zhpt01 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16,
       dimension( * ) AFAC, integer, dimension( * ) IPIV, complex*16, dimension( ldc, * ) C,
       integer LDC, double precision, dimension( * ) RWORK, double precision RESID)
       ZHPT01

       Purpose:

            ZHPT01 reconstructs a Hermitian indefinite packed matrix A from its
            block L*D*L' or U*D*U' factorization and computes the residual
               norm( C - A ) / ( N * norm(A) * EPS ),
            where C is the reconstructed matrix, EPS is the machine epsilon,
            L' is the conjugate transpose of L, and U' is the conjugate transpose
            of U.

       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 number of rows and columns of the matrix A.  N >= 0.

           A

                     A is COMPLEX*16 array, dimension (N*(N+1)/2)
                     The original Hermitian matrix A, stored as a packed
                     triangular matrix.

           AFAC

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

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     The pivot indices from ZHPTRF.

           C

                     C is COMPLEX*16 array, dimension (LDC,N)

           LDC

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
                     If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlahilb (integer N, integer NRHS, complex*16, dimension(lda,n) A, integer LDA,
       complex*16, dimension(ldx, nrhs) X, integer LDX, complex*16, dimension(ldb, nrhs) B,
       integer LDB, double precision, dimension(n) WORK, integer INFO, character*3 PATH)
       ZLAHILB

       Purpose:

            ZLAHILB generates an N by N scaled Hilbert matrix in A along with
            NRHS right-hand sides in B and solutions in X such that A*X=B.

            The Hilbert matrix is scaled by M = LCM(1, 2, ..., 2*N-1) so that all
            entries are integers.  The right-hand sides are the first NRHS
            columns of M * the identity matrix, and the solutions are the
            first NRHS columns of the inverse Hilbert matrix.

            The condition number of the Hilbert matrix grows exponentially with
            its size, roughly as O(e ** (3.5*N)).  Additionally, the inverse
            Hilbert matrices beyond a relatively small dimension cannot be
            generated exactly without extra precision.  Precision is exhausted
            when the largest entry in the inverse Hilbert matrix is greater than
            2 to the power of the number of bits in the fraction of the data type
            used plus one, which is 24 for single precision.

            In single, the generated solution is exact for N <= 6 and has
            small componentwise error for 7 <= N <= 11.

       Parameters:
           N

                     N is INTEGER
                     The dimension of the matrix A.

           NRHS

                     NRHS is NRHS
                     The requested number of right-hand sides.

           A

                     A is COMPLEX array, dimension (LDA, N)
                     The generated scaled Hilbert matrix.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= N.

           X

                     X is COMPLEX array, dimension (LDX, NRHS)
                     The generated exact solutions.  Currently, the first NRHS
                     columns of the inverse Hilbert matrix.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  LDX >= N.

           B

                     B is REAL array, dimension (LDB, NRHS)
                     The generated right-hand sides.  Currently, the first NRHS
                     columns of LCM(1, 2, ..., 2*N-1) * the identity matrix.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= N.

           WORK

                     WORK is REAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0: successful exit
                     = 1: N is too large; the data is still generated but may not
                          be not exact.
                     < 0: if INFO = -i, the i-th argument had an illegal value

           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlaipd (integer N, complex*16, dimension( * ) A, integer INDA, integer VINDA)
       ZLAIPD

       Purpose:

            ZLAIPD sets the imaginary part of the diagonal elements of a complex
            matrix A to a large value.  This is used to test LAPACK routines for
            complex Hermitian matrices, which are not supposed to access or use
            the imaginary parts of the diagonals.

       Parameters:
           N

                     N is INTEGER
                    The number of diagonal elements of A.

           A

                     A is COMPLEX*16 array, dimension
                                   (1+(N-1)*INDA+(N-2)*VINDA)
                    On entry, the complex (Hermitian) matrix A.
                    On exit, the imaginary parts of the diagonal elements are set
                    to BIGNUM = EPS / SAFMIN, where EPS is the machine epsilon and
                    SAFMIN is the safe minimum.

           INDA

                     INDA is INTEGER
                    The increment between A(1) and the next diagonal element of A.
                    Typical values are
                    = LDA+1:  square matrices with leading dimension LDA
                    = 2:  packed upper triangular matrix, starting at A(1,1)
                    = N:  packed lower triangular matrix, starting at A(1,1)

           VINDA

                     VINDA is INTEGER
                    The change in the diagonal increment between columns of A.
                    Typical values are
                    = 0:  no change, the row and column increments in A are fixed
                    = 1:  packed upper triangular matrix
                    = -1:  packed lower triangular matrix

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlaptm (character UPLO, integer N, integer NRHS, double precision ALPHA, double
       precision, dimension( * ) D, complex*16, dimension( * ) E, complex*16, dimension( ldx, * )
       X, integer LDX, double precision BETA, complex*16, dimension( ldb, * ) B, integer LDB)
       ZLAPTM

       Purpose:

            ZLAPTM multiplies an N by NRHS matrix X by a Hermitian tridiagonal
            matrix A and stores the result in a matrix B.  The operation has the
            form

               B := alpha * A * X + beta * B

            where alpha may be either 1. or -1. and beta may be 0., 1., or -1.

       Parameters:
           UPLO

                     UPLO is CHARACTER
                     Specifies whether the superdiagonal or the subdiagonal of the
                     tridiagonal matrix A is stored.
                     = 'U':  Upper, E is the superdiagonal of A.
                     = 'L':  Lower, E is the subdiagonal of A.

           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 X and B.

           ALPHA

                     ALPHA is DOUBLE PRECISION
                     The scalar alpha.  ALPHA must be 1. or -1.; otherwise,
                     it is assumed to be 0.

           D

                     D is DOUBLE PRECISION array, dimension (N)
                     The n diagonal elements of the tridiagonal matrix A.

           E

                     E is COMPLEX*16 array, dimension (N-1)
                     The (n-1) subdiagonal or superdiagonal elements of A.

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The N by NRHS matrix X.

           LDX

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

           BETA

                     BETA is DOUBLE PRECISION
                     The scalar beta.  BETA must be 0., 1., or -1.; otherwise,
                     it is assumed to be 1.

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the N by NRHS matrix B.
                     On exit, B is overwritten by the matrix expression
                     B := alpha * A * X + beta * B.

           LDB

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

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlarhs (character*3 PATH, character XTYPE, character UPLO, character TRANS, integer
       M, integer N, integer KL, integer KU, integer NRHS, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, *
       ) B, integer LDB, integer, dimension( 4 ) ISEED, integer INFO)
       ZLARHS

       Purpose:

            ZLARHS chooses a set of NRHS random solution vectors and sets
            up the right hand sides for the linear system
               op( A ) * X = B,
            where op( A ) may be A, A**T (transpose of A), or A**H (conjugate
            transpose of A).

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The type of the complex matrix A.  PATH may be given in any
                     combination of upper and lower case.  Valid paths include
                        xGE:  General m x n matrix
                        xGB:  General banded matrix
                        xPO:  Hermitian positive definite, 2-D storage
                        xPP:  Hermitian positive definite packed
                        xPB:  Hermitian positive definite banded
                        xHE:  Hermitian indefinite, 2-D storage
                        xHP:  Hermitian indefinite packed
                        xHB:  Hermitian indefinite banded
                        xSY:  Symmetric indefinite, 2-D storage
                        xSP:  Symmetric indefinite packed
                        xSB:  Symmetric indefinite banded
                        xTR:  Triangular
                        xTP:  Triangular packed
                        xTB:  Triangular banded
                        xQR:  General m x n matrix
                        xLQ:  General m x n matrix
                        xQL:  General m x n matrix
                        xRQ:  General m x n matrix
                     where the leading character indicates the precision.

           XTYPE

                     XTYPE is CHARACTER*1
                     Specifies how the exact solution X will be determined:
                     = 'N':  New solution; generate a random X.
                     = 'C':  Computed; use value of X on entry.

           UPLO

                     UPLO is CHARACTER*1
                     Used only if A is symmetric or triangular; specifies whether
                     the upper or lower triangular part of the matrix A is stored.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           TRANS

                     TRANS is CHARACTER*1
                     Used only if A is nonsymmetric; specifies the operation
                     applied to the matrix A.
                     = 'N':  B := A    * X
                     = 'T':  B := A**T * X
                     = 'C':  B := A**H * X

           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.

           KL

                     KL is INTEGER
                     Used only if A is a band matrix; specifies the number of
                     subdiagonals of A if A is a general band matrix or if A is
                     symmetric or triangular and UPLO = 'L'; specifies the number
                     of superdiagonals of A if A is symmetric or triangular and
                     UPLO = 'U'.  0 <= KL <= M-1.

           KU

                     KU is INTEGER
                     Used only if A is a general band matrix or if A is
                     triangular.

                     If PATH = xGB, specifies the number of superdiagonals of A,
                     and 0 <= KU <= N-1.

                     If PATH = xTR, xTP, or xTB, specifies whether or not the
                     matrix has unit diagonal:
                     = 1:  matrix has non-unit diagonal (default)
                     = 2:  matrix has unit diagonal

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors in the system A*X = B.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The test matrix whose type is given by PATH.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.
                     If PATH = xGB, LDA >= KL+KU+1.
                     If PATH = xPB, xSB, xHB, or xTB, LDA >= KL+1.
                     Otherwise, LDA >= max(1,M).

           X

                     X is or output) COMPLEX*16 array, dimension (LDX,NRHS)
                     On entry, if XTYPE = 'C' (for 'Computed'), then X contains
                     the exact solution to the system of linear equations.
                     On exit, if XTYPE = 'N' (for 'New'), then X is initialized
                     with random values.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  If TRANS = 'N',
                     LDX >= max(1,N); if TRANS = 'T', LDX >= max(1,M).

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vector(s) for the system of equations,
                     computed from B = op(A) * X, where op(A) is determined by
                     TRANS.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  If TRANS = 'N',
                     LDB >= max(1,M); if TRANS = 'T', LDB >= max(1,N).

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     The seed vector for the random number generator (used in
                     ZLATMS).  Modified on exit.

           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.

       Date:
           November 2011

   subroutine zlatb4 (character*3 PATH, integer IMAT, integer M, integer N, character TYPE,
       integer KL, integer KU, double precision ANORM, integer MODE, double precision CNDNUM,
       character DIST)
       ZLATB4

       Purpose:

            ZLATB4 sets parameters for the matrix generator based on the type of
            matrix to be generated.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name.

           IMAT

                     IMAT is INTEGER
                     An integer key describing which matrix to generate for this
                     path.

           M

                     M is INTEGER
                     The number of rows in the matrix to be generated.

           N

                     N is INTEGER
                     The number of columns in the matrix to be generated.

           TYPE

                     TYPE is CHARACTER*1
                     The type of the matrix to be generated:
                     = 'S':  symmetric matrix
                     = 'H':  Hermitian matrix
                     = 'P':  Hermitian positive (semi)definite matrix
                     = 'N':  nonsymmetric matrix

           KL

                     KL is INTEGER
                     The lower band width of the matrix to be generated.

           KU

                     KU is INTEGER
                     The upper band width of the matrix to be generated.

           ANORM

                     ANORM is DOUBLE PRECISION
                     The desired norm of the matrix to be generated.  The diagonal
                     matrix of singular values or eigenvalues is scaled by this
                     value.

           MODE

                     MODE is INTEGER
                     A key indicating how to choose the vector of eigenvalues.

           CNDNUM

                     CNDNUM is DOUBLE PRECISION
                     The desired condition number.

           DIST

                     DIST is CHARACTER*1
                     The type of distribution to be used by the random number
                     generator.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zlatb5 (character*3 PATH, integer IMAT, integer N, character TYPE, integer KL,
       integer KU, double precision ANORM, integer MODE, double precision CNDNUM, character DIST)
       ZLATB5

       Purpose:

            ZLATB5 sets parameters for the matrix generator based on the type
            of matrix to be generated.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name.

           IMAT

                     IMAT is INTEGER
                     An integer key describing which matrix to generate for this
                     path.

           N

                     N is INTEGER
                     The number of rows and columns in the matrix to be generated.

           TYPE

                     TYPE is CHARACTER*1
                     The type of the matrix to be generated:
                     = 'S':  symmetric matrix
                     = 'P':  symmetric positive (semi)definite matrix
                     = 'N':  nonsymmetric matrix

           KL

                     KL is INTEGER
                     The lower band width of the matrix to be generated.

           KU

                     KU is INTEGER
                     The upper band width of the matrix to be generated.

           ANORM

                     ANORM is DOUBLE PRECISION
                     The desired norm of the matrix to be generated.  The diagonal
                     matrix of singular values or eigenvalues is scaled by this
                     value.

           MODE

                     MODE is INTEGER
                     A key indicating how to choose the vector of eigenvalues.

           CNDNUM

                     CNDNUM is DOUBLE PRECISION
                     The desired condition number.

           DIST

                     DIST is CHARACTER*1
                     The type of distribution to be used by the random number
                     generator.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlatsp (character UPLO, integer N, complex*16, dimension( * ) X, integer,
       dimension( * ) ISEED)
       ZLATSP

       Purpose:

            ZLATSP generates a special test matrix for the complex symmetric
            (indefinite) factorization for packed matrices.  The pivot blocks of
            the generated matrix will be in the following order:
               2x2 pivot block, non diagonalizable
               1x1 pivot block
               2x2 pivot block, diagonalizable
               (cycle repeats)
            A row interchange is required for each non-diagonalizable 2x2 block.

       Parameters:
           UPLO

                     UPLO is CHARACTER
                     Specifies whether the generated matrix is to be upper or
                     lower triangular.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           N

                     N is INTEGER
                     The dimension of the matrix to be generated.

           X

                     X is COMPLEX*16 array, dimension (N*(N+1)/2)
                     The generated matrix in packed storage format.  The matrix
                     consists of 3x3 and 2x2 diagonal blocks which result in the
                     pivot sequence given above.  The matrix outside these
                     diagonal blocks is zero.

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     On entry, the seed for the random number generator.  The last
                     of the four integers must be odd.  (modified on exit)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlatsy (character UPLO, integer N, complex*16, dimension( ldx, * ) X, integer LDX,
       integer, dimension( * ) ISEED)
       ZLATSY

       Purpose:

            ZLATSY generates a special test matrix for the complex symmetric
            (indefinite) factorization.  The pivot blocks of the generated matrix
            will be in the following order:
               2x2 pivot block, non diagonalizable
               1x1 pivot block
               2x2 pivot block, diagonalizable
               (cycle repeats)
            A row interchange is required for each non-diagonalizable 2x2 block.

       Parameters:
           UPLO

                     UPLO is CHARACTER
                     Specifies whether the generated matrix is to be upper or
                     lower triangular.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           N

                     N is INTEGER
                     The dimension of the matrix to be generated.

           X

                     X is COMPLEX*16 array, dimension (LDX,N)
                     The generated matrix, consisting of 3x3 and 2x2 diagonal
                     blocks which result in the pivot sequence given above.
                     The matrix outside of these diagonal blocks is zero.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     On entry, the seed for the random number generator.  The last
                     of the four integers must be odd.  (modified on exit)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlattb (integer IMAT, character UPLO, character TRANS, character DIAG, integer,
       dimension( 4 ) ISEED, integer N, integer KD, complex*16, dimension( ldab, * ) AB, integer
       LDAB, complex*16, dimension( * ) B, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer INFO)
       ZLATTB

       Purpose:

            ZLATTB generates a triangular test matrix in 2-dimensional storage.
            IMAT and UPLO uniquely specify the properties of the test matrix,
            which is returned in the array A.

       Parameters:
           IMAT

                     IMAT is INTEGER
                     An integer key describing which matrix to generate for this
                     path.

           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the matrix A will be upper or lower
                     triangular.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           TRANS

                     TRANS is CHARACTER*1
                     Specifies whether the matrix or its transpose will be used.
                     = 'N':  No transpose
                     = 'T':  Transpose
                     = 'C':  Conjugate transpose (= transpose)

           DIAG

                     DIAG is CHARACTER*1
                     Specifies whether or not the matrix A is unit triangular.
                     = 'N':  Non-unit triangular
                     = 'U':  Unit triangular

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     The seed vector for the random number generator (used in
                     ZLATMS).  Modified on exit.

           N

                     N is INTEGER
                     The order of the matrix to be generated.

           KD

                     KD is INTEGER
                     The number of superdiagonals or subdiagonals of the banded
                     triangular matrix A.  KD >= 0.

           AB

                     AB is COMPLEX*16 array, dimension (LDAB,N)
                     The upper or lower triangular banded matrix A, stored in the
                     first KD+1 rows of AB.  Let j be a column of A, 1<=j<=n.
                     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.

           B

                     B is COMPLEX*16 array, dimension (N)

           WORK

                     WORK is COMPLEX*16 array, dimension (2*N)

           RWORK

                     RWORK is DOUBLE PRECISION 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.

       Date:
           November 2011

   subroutine zlattp (integer IMAT, character UPLO, character TRANS, character DIAG, integer,
       dimension( 4 ) ISEED, integer N, complex*16, dimension( * ) AP, complex*16, dimension( * )
       B, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer INFO)
       ZLATTP

       Purpose:

            ZLATTP generates a triangular test matrix in packed storage.
            IMAT and UPLO uniquely specify the properties of the test matrix,
            which is returned in the array AP.

       Parameters:
           IMAT

                     IMAT is INTEGER
                     An integer key describing which matrix to generate for this
                     path.

           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the matrix A will be upper or lower
                     triangular.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           TRANS

                     TRANS is CHARACTER*1
                     Specifies whether the matrix or its transpose will be used.
                     = 'N':  No transpose
                     = 'T':  Transpose
                     = 'C':  Conjugate transpose

           DIAG

                     DIAG is CHARACTER*1
                     Specifies whether or not the matrix A is unit triangular.
                     = 'N':  Non-unit triangular
                     = 'U':  Unit triangular

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     The seed vector for the random number generator (used in
                     ZLATMS).  Modified on exit.

           N

                     N is INTEGER
                     The order of the matrix to be generated.

           AP

                     AP is COMPLEX*16 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((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L',
                        AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.

           B

                     B is COMPLEX*16 array, dimension (N)
                     The right hand side vector, if IMAT > 10.

           WORK

                     WORK is COMPLEX*16 array, dimension (2*N)

           RWORK

                     RWORK is DOUBLE PRECISION 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.

       Date:
           November 2011

   subroutine zlattr (integer IMAT, character UPLO, character TRANS, character DIAG, integer,
       dimension( 4 ) ISEED, integer N, complex*16, dimension( lda, * ) A, integer LDA,
       complex*16, dimension( * ) B, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer INFO)
       ZLATTR

       Purpose:

            ZLATTR generates a triangular test matrix in 2-dimensional storage.
            IMAT and UPLO uniquely specify the properties of the test matrix,
            which is returned in the array A.

       Parameters:
           IMAT

                     IMAT is INTEGER
                     An integer key describing which matrix to generate for this
                     path.

           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the matrix A will be upper or lower
                     triangular.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           TRANS

                     TRANS is CHARACTER*1
                     Specifies whether the matrix or its transpose will be used.
                     = 'N':  No transpose
                     = 'T':  Transpose
                     = 'C':  Conjugate transpose

           DIAG

                     DIAG is CHARACTER*1
                     Specifies whether or not the matrix A is unit triangular.
                     = 'N':  Non-unit triangular
                     = 'U':  Unit triangular

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     The seed vector for the random number generator (used in
                     ZLATMS).  Modified on exit.

           N

                     N is INTEGER
                     The order of the matrix to be generated.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The triangular matrix A.  If UPLO = 'U', the leading N x 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 x 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).

           B

                     B is COMPLEX*16 array, dimension (N)
                     The right hand side vector, if IMAT > 10.

           WORK

                     WORK is COMPLEX*16 array, dimension (2*N)

           RWORK

                     RWORK is DOUBLE PRECISION 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.

       Date:
           November 2011

   subroutine zlavhe (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex*16, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV, complex*16,
       dimension( ldb, * ) B, integer LDB, integer INFO)
       ZLAVHE

       Purpose:

            ZLAVHE performs one of the matrix-vector operations
               x := A*x  or  x := A^H*x,
            where x is an N element vector and  A is one of the factors
            from the block U*D*U' or L*D*L' factorization computed by ZHETRF.

            If TRANS = 'N', multiplies by U  or U * D  (or L  or L * D)
            If TRANS = 'C', multiplies by U' or D * U' (or L' or D * L')

       Parameters:
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the factor stored in A is upper or lower
                     triangular.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the operation to be performed:
                     = 'N':  x := A*x
                     = 'C':  x := A'*x

           DIAG

                     DIAG is CHARACTER*1
                     Specifies whether or not the diagonal blocks are unit
                     matrices.  If the diagonal blocks are assumed to be unit,
                     then A = U or A = L, otherwise A = U*D or A = L*D.
                     = 'U':  Diagonal blocks are assumed to be unit matrices.
                     = 'N':  Diagonal blocks are assumed to be non-unit matrices.

           N

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

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of vectors
                     x to be multiplied by A.  NRHS >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The block diagonal matrix D and the multipliers used to
                     obtain the factor U or L as computed by ZHETRF.
                     Stored as a 2-D triangular matrix.

           LDA

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

           IPIV

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

                     If UPLO = 'U':
                          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 IPIV( k ) = k, no interchange was done).

                          If IPIV(k) = IPIV(k-1) < 0, then rows and
                          columns k-1 and -IPIV(k) were interchanged,
                          D(k-1:k,k-1:k) is a 2-by-2 diagonal block.

                     If UPLO = 'L':
                          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 IPIV( k ) = k, no interchange was done).

                          If IPIV(k) = IPIV(k+1) < 0, then rows and
                          columns k+1 and -IPIV(k) were interchanged,
                          D(k:k+1,k:k+1) is a 2-by-2 diagonal block.

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, B contains NRHS vectors of length N.
                     On exit, B is overwritten with the product A * B.

           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 = -k, the k-th argument had an illegal value

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zlavhe_rook (character UPLO, character TRANS, character DIAG, integer N, integer
       NRHS, complex*16, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV,
       complex*16, dimension( ldb, * ) B, integer LDB, integer INFO)
       ZLAVHE_ROOK

       Purpose:
           ZLAVHE_ROOK performs one of the matrix-vector operations x := A*x or x := A^H*x, where
           x is an N element vector and A is one of the factors from the block U*D*U' or L*D*L'
           factorization computed by ZHETRF_ROOK.

       If TRANS = 'N', multiplies by U or U * D (or L or L * D) If TRANS = 'C', multiplies by U'
       or D * U' (or L' or D * L')

       Parameters:
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the factor stored in A is upper or lower
                     triangular.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the operation to be performed:
                     = 'N':  x := A*x
                     = 'C':   x := A^H*x

           DIAG

                     DIAG is CHARACTER*1
                     Specifies whether or not the diagonal blocks are unit
                     matrices.  If the diagonal blocks are assumed to be unit,
                     then A = U or A = L, otherwise A = U*D or A = L*D.
                     = 'U':  Diagonal blocks are assumed to be unit matrices.
                     = 'N':  Diagonal blocks are assumed to be non-unit matrices.

           N

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

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of vectors
                     x to be multiplied by A.  NRHS >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The block diagonal matrix D and the multipliers used to
                     obtain the factor U or L as computed by ZHETRF_ROOK.
                     Stored as a 2-D triangular matrix.

           LDA

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

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     Details of the interchanges and the block structure of D,
                     as determined by ZHETRF_ROOK.
                     If UPLO = 'U':
                        Only the last KB elements of IPIV are set.

                        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 IPIV(k) < 0 and IPIV(k-1) < 0, then rows and
                        columns k and -IPIV(k) were interchanged and rows and
                        columns k-1 and -IPIV(k-1) were inerchaged,
                        D(k-1:k,k-1:k) is a 2-by-2 diagonal block.

                     If UPLO = 'L':
                        Only the first KB elements of IPIV are set.

                        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 IPIV(k) < 0 and IPIV(k+1) < 0, then rows and
                        columns k and -IPIV(k) were interchanged and rows and
                        columns k+1 and -IPIV(k+1) were inerchaged,
                        D(k:k+1,k:k+1) is a 2-by-2 diagonal block.

           B

                     B is COMPLEX array, dimension (LDB,NRHS)
                     On entry, B contains NRHS vectors of length N.
                     On exit, B is overwritten with the product A * B.

           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 = -k, the k-th argument had an illegal value

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zlavhp (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex*16, dimension( * ) A, integer, dimension( * ) IPIV, complex*16, dimension( ldb, *
       ) B, integer LDB, integer INFO)
       ZLAVHP

       Purpose:

               ZLAVHP  performs one of the matrix-vector operations
                  x := A*x  or  x := A^H*x,
               where x is an N element vector and  A is one of the factors
               from the symmetric factorization computed by ZHPTRF.
               ZHPTRF produces a factorization of the form
                    U * D * U^H     or     L * D * L^H,
               where U (or L) is a product of permutation and unit upper (lower)
               triangular matrices, U^H (or L^H) is the conjugate transpose of
               U (or L), and D is Hermitian and block diagonal with 1 x 1 and
               2 x 2 diagonal blocks.  The multipliers for the transformations
               and the upper or lower triangular parts of the diagonal blocks
               are stored columnwise in packed format in the linear array A.

               If TRANS = 'N' or 'n', ZLAVHP multiplies either by U or U * D
               (or L or L * D).
               If TRANS = 'C' or 'c', ZLAVHP multiplies either by U^H or D * U^H
               (or L^H or D * L^H ).

             UPLO   - CHARACTER*1
                      On entry, UPLO specifies whether the triangular matrix
                      stored in A is upper or lower triangular.
                         UPLO = 'U' or 'u'   The matrix is upper triangular.
                         UPLO = 'L' or 'l'   The matrix is lower triangular.
                      Unchanged on exit.

             TRANS  - CHARACTER*1
                      On entry, TRANS specifies the operation to be performed as
                      follows:
                         TRANS = 'N' or 'n'   x := A*x.
                         TRANS = 'C' or 'c'   x := A^H*x.
                      Unchanged on exit.

             DIAG   - CHARACTER*1
                      On entry, DIAG specifies whether the diagonal blocks are
                      assumed to be unit matrices, as follows:
                         DIAG = 'U' or 'u'   Diagonal blocks are unit matrices.
                         DIAG = 'N' or 'n'   Diagonal blocks are non-unit.
                      Unchanged on exit.

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

             NRHS   - INTEGER
                      On entry, NRHS specifies the number of right hand sides,
                      i.e., the number of vectors x to be multiplied by A.
                      NRHS must be at least zero.
                      Unchanged on exit.

             A      - COMPLEX*16 array, dimension( N*(N+1)/2 )
                      On entry, A contains a block diagonal matrix and the
                      multipliers of the transformations used to obtain it,
                      stored as a packed triangular matrix.
                      Unchanged on exit.

             IPIV   - INTEGER array, dimension( N )
                      On entry, IPIV contains the vector of pivot indices as
                      determined by ZSPTRF or ZHPTRF.
                      If IPIV( K ) = K, no interchange was done.
                      If IPIV( K ) <> K but IPIV( K ) > 0, then row K was inter-
                      changed with row IPIV( K ) and a 1 x 1 pivot block was used.
                      If IPIV( K ) < 0 and UPLO = 'U', then row K-1 was exchanged
                      with row | IPIV( K ) | and a 2 x 2 pivot block was used.
                      If IPIV( K ) < 0 and UPLO = 'L', then row K+1 was exchanged
                      with row | IPIV( K ) | and a 2 x 2 pivot block was used.

             B      - COMPLEX*16 array, dimension( LDB, NRHS )
                      On entry, B contains NRHS vectors of length N.
                      On exit, B is overwritten with the product A * B.

             LDB    - INTEGER
                      On entry, LDB contains the leading dimension of B as
                      declared in the calling program.  LDB must be at least
                      max( 1, N ).
                      Unchanged on exit.

             INFO   - INTEGER
                      INFO is the error flag.
                      On exit, a value of 0 indicates a successful exit.
                      A negative value, say -K, indicates that the K-th argument
                      has an illegal value.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlavsp (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex*16, dimension( * ) A, integer, dimension( * ) IPIV, complex*16, dimension( ldb, *
       ) B, integer LDB, integer INFO)
       ZLAVSP

       Purpose:

               ZLAVSP  performs one of the matrix-vector operations
                  x := A*x  or  x := A^T*x,
               where x is an N element vector and  A is one of the factors
               from the symmetric factorization computed by ZSPTRF.
               ZSPTRF produces a factorization of the form
                    U * D * U^T     or     L * D * L^T,
               where U (or L) is a product of permutation and unit upper (lower)
               triangular matrices, U^T (or L^T) is the transpose of
               U (or L), and D is symmetric and block diagonal with 1 x 1 and
               2 x 2 diagonal blocks.  The multipliers for the transformations
               and the upper or lower triangular parts of the diagonal blocks
               are stored columnwise in packed format in the linear array A.

               If TRANS = 'N' or 'n', ZLAVSP multiplies either by U or U * D
               (or L or L * D).
               If TRANS = 'C' or 'c', ZLAVSP multiplies either by U^T or D * U^T
               (or L^T or D * L^T ).

             UPLO   - CHARACTER*1
                      On entry, UPLO specifies whether the triangular matrix
                      stored in A is upper or lower triangular.
                         UPLO = 'U' or 'u'   The matrix is upper triangular.
                         UPLO = 'L' or 'l'   The matrix is lower triangular.
                      Unchanged on exit.

             TRANS  - CHARACTER*1
                      On entry, TRANS specifies the operation to be performed as
                      follows:
                         TRANS = 'N' or 'n'   x := A*x.
                         TRANS = 'T' or 't'   x := A^T*x.
                      Unchanged on exit.

             DIAG   - CHARACTER*1
                      On entry, DIAG specifies whether the diagonal blocks are
                      assumed to be unit matrices, as follows:
                         DIAG = 'U' or 'u'   Diagonal blocks are unit matrices.
                         DIAG = 'N' or 'n'   Diagonal blocks are non-unit.
                      Unchanged on exit.

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

             NRHS   - INTEGER
                      On entry, NRHS specifies the number of right hand sides,
                      i.e., the number of vectors x to be multiplied by A.
                      NRHS must be at least zero.
                      Unchanged on exit.

             A      - COMPLEX*16 array, dimension( N*(N+1)/2 )
                      On entry, A contains a block diagonal matrix and the
                      multipliers of the transformations used to obtain it,
                      stored as a packed triangular matrix.
                      Unchanged on exit.

             IPIV   - INTEGER array, dimension( N )
                      On entry, IPIV contains the vector of pivot indices as
                      determined by ZSPTRF.
                      If IPIV( K ) = K, no interchange was done.
                      If IPIV( K ) <> K but IPIV( K ) > 0, then row K was inter-
                      changed with row IPIV( K ) and a 1 x 1 pivot block was used.
                      If IPIV( K ) < 0 and UPLO = 'U', then row K-1 was exchanged
                      with row | IPIV( K ) | and a 2 x 2 pivot block was used.
                      If IPIV( K ) < 0 and UPLO = 'L', then row K+1 was exchanged
                      with row | IPIV( K ) | and a 2 x 2 pivot block was used.

             B      - COMPLEX*16 array, dimension( LDB, NRHS )
                      On entry, B contains NRHS vectors of length N.
                      On exit, B is overwritten with the product A * B.

             LDB    - INTEGER
                      On entry, LDB contains the leading dimension of B as
                      declared in the calling program.  LDB must be at least
                      max( 1, N ).
                      Unchanged on exit.

             INFO   - INTEGER
                      INFO is the error flag.
                      On exit, a value of 0 indicates a successful exit.
                      A negative value, say -K, indicates that the K-th argument
                      has an illegal value.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlavsy (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex*16, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV, complex*16,
       dimension( ldb, * ) B, integer LDB, integer INFO)
       ZLAVSY

       Purpose:

            ZLAVSY performs one of the matrix-vector operations
               x := A*x  or  x := A'*x,
            where x is an N element vector and  A is one of the factors
            from the block U*D*U' or L*D*L' factorization computed by ZSYTRF.

            If TRANS = 'N', multiplies by U  or U * D  (or L  or L * D)
            If TRANS = 'T', multiplies by U' or D * U' (or L' or D * L')

       Parameters:
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the factor stored in A is upper or lower
                     triangular.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the operation to be performed:
                     = 'N':  x := A*x
                     = 'T':  x := A'*x

           DIAG

                     DIAG is CHARACTER*1
                     Specifies whether or not the diagonal blocks are unit
                     matrices.  If the diagonal blocks are assumed to be unit,
                     then A = U or A = L, otherwise A = U*D or A = L*D.
                     = 'U':  Diagonal blocks are assumed to be unit matrices.
                     = 'N':  Diagonal blocks are assumed to be non-unit matrices.

           N

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

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of vectors
                     x to be multiplied by A.  NRHS >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The block diagonal matrix D and the multipliers used to
                     obtain the factor U or L as computed by ZSYTRF.
                     Stored as a 2-D triangular matrix.

           LDA

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

           IPIV

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

                     If UPLO = 'U':
                          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 IPIV( k ) = k, no interchange was done).

                          If IPIV(k) = IPIV(k-1) < 0, then rows and
                          columns k-1 and -IPIV(k) were interchanged,
                          D(k-1:k,k-1:k) is a 2-by-2 diagonal block.

                     If UPLO = 'L':
                          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 IPIV( k ) = k, no interchange was done).

                          If IPIV(k) = IPIV(k+1) < 0, then rows and
                          columns k+1 and -IPIV(k) were interchanged,
                          D(k:k+1,k:k+1) is a 2-by-2 diagonal block.

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, B contains NRHS vectors of length N.
                     On exit, B is overwritten with the product A * B.

           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 = -k, the k-th argument had an illegal value

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zlavsy_rook (character UPLO, character TRANS, character DIAG, integer N, integer
       NRHS, complex*16, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV,
       complex*16, dimension( ldb, * ) B, integer LDB, integer INFO)
       ZLAVSY_ROOK

       Purpose:

            ZLAVSY_ROOK performs one of the matrix-vector operations
               x := A*x  or  x := A'*x,
            where x is an N element vector and  A is one of the factors
            from the block U*D*U' or L*D*L' factorization computed by ZSYTRF_ROOK.

            If TRANS = 'N', multiplies by U  or U * D  (or L  or L * D)
            If TRANS = 'T', multiplies by U' or D * U' (or L' or D * L')

       Parameters:
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the factor stored in A is upper or lower
                     triangular.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the operation to be performed:
                     = 'N':  x := A*x
                     = 'T':  x := A'*x

           DIAG

                     DIAG is CHARACTER*1
                     Specifies whether or not the diagonal blocks are unit
                     matrices.  If the diagonal blocks are assumed to be unit,
                     then A = U or A = L, otherwise A = U*D or A = L*D.
                     = 'U':  Diagonal blocks are assumed to be unit matrices.
                     = 'N':  Diagonal blocks are assumed to be non-unit matrices.

           N

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

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of vectors
                     x to be multiplied by A.  NRHS >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The block diagonal matrix D and the multipliers used to
                     obtain the factor U or L as computed by ZSYTRF_ROOK.
                     Stored as a 2-D triangular matrix.

           LDA

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

           IPIV

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

                     If UPLO = 'U':
                          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 IPIV( k ) = k, no interchange was done).

                          If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and
                          columns k and -IPIV(k) were interchanged and rows and
                          columns k-1 and -IPIV(k-1) were inerchaged,
                          D(k-1:k,k-1:k) is a 2-by-2 diagonal block.

                     If UPLO = 'L':
                          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 IPIV( k ) = k, no interchange was done).

                          If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and
                          columns k and -IPIV(k) were interchanged and rows and
                          columns k+1 and -IPIV(k+1) were inerchaged,
                          D(k:k+1,k:k+1) is a 2-by-2 diagonal block.

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, B contains NRHS vectors of length N.
                     On exit, B is overwritten with the product A * B.

           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 = -k, the k-th argument had an illegal value

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zlqt01 (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16,
       dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * )
       L, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK,
       integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * )
       RESULT)
       ZLQT01

       Purpose:

            ZLQT01 tests ZGELQF, which computes the LQ factorization of an m-by-n
            matrix A, and partially tests ZUNGLQ which forms the n-by-n
            orthogonal matrix Q.

            ZLQT01 compares L with A*Q', and checks that Q is orthogonal.

       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.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The m-by-n matrix A.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the LQ factorization of A, as returned by ZGELQF.
                     See ZGELQF for further details.

           Q

                     Q is COMPLEX*16 array, dimension (LDA,N)
                     The n-by-n orthogonal matrix Q.

           L

                     L is COMPLEX*16 array, dimension (LDA,max(M,N))

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A, AF, Q and L.
                     LDA >= max(M,N).

           TAU

                     TAU is COMPLEX*16 array, dimension (min(M,N))
                     The scalar factors of the elementary reflectors, as returned
                     by ZGELQF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (max(M,N))

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The test ratios:
                     RESULT(1) = norm( L - A*Q' ) / ( N * norm(A) * EPS )
                     RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlqt02 (integer M, integer N, integer K, complex*16, dimension( lda, * ) A,
       complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16,
       dimension( lda, * ) L, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
       lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
       dimension( * ) RESULT)
       ZLQT02

       Purpose:

            ZLQT02 tests ZUNGLQ, which generates an m-by-n matrix Q with
            orthonornmal rows that is defined as the product of k elementary
            reflectors.

            Given the LQ factorization of an m-by-n matrix A, ZLQT02 generates
            the orthogonal matrix Q defined by the factorization of the first k
            rows of A; it compares L(1:k,1:m) with A(1:k,1:n)*Q(1:m,1:n)', and
            checks that the rows of Q are orthonormal.

       Parameters:
           M

                     M is INTEGER
                     The number of rows of the matrix Q to be generated.  M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix Q to be generated.
                     N >= M >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     matrix Q. M >= K >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The m-by-n matrix A which was factorized by ZLQT01.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the LQ factorization of A, as returned by ZGELQF.
                     See ZGELQF for further details.

           Q

                     Q is COMPLEX*16 array, dimension (LDA,N)

           L

                     L is COMPLEX*16 array, dimension (LDA,M)

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A, AF, Q and L. LDA >= N.

           TAU

                     TAU is COMPLEX*16 array, dimension (M)
                     The scalar factors of the elementary reflectors corresponding
                     to the LQ factorization in AF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The test ratios:
                     RESULT(1) = norm( L - A*Q' ) / ( N * norm(A) * EPS )
                     RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlqt03 (integer M, integer N, integer K, complex*16, dimension( lda, * ) AF,
       complex*16, dimension( lda, * ) C, complex*16, dimension( lda, * ) CC, complex*16,
       dimension( lda, * ) Q, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
       lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
       dimension( * ) RESULT)
       ZLQT03

       Purpose:

            ZLQT03 tests ZUNMLQ, which computes Q*C, Q'*C, C*Q or C*Q'.

            ZLQT03 compares the results of a call to ZUNMLQ with the results of
            forming Q explicitly by a call to ZUNGLQ and then performing matrix
            multiplication by a call to ZGEMM.

       Parameters:
           M

                     M is INTEGER
                     The number of rows or columns of the matrix C; C is n-by-m if
                     Q is applied from the left, or m-by-n if Q is applied from
                     the right.  M >= 0.

           N

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

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     orthogonal matrix Q.  N >= K >= 0.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the LQ factorization of an m-by-n matrix, as
                     returned by ZGELQF. See CGELQF for further details.

           C

                     C is COMPLEX*16 array, dimension (LDA,N)

           CC

                     CC is COMPLEX*16 array, dimension (LDA,N)

           Q

                     Q is COMPLEX*16 array, dimension (LDA,N)

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays AF, C, CC, and Q.

           TAU

                     TAU is COMPLEX*16 array, dimension (min(M,N))
                     The scalar factors of the elementary reflectors corresponding
                     to the LQ factorization in AF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of WORK.  LWORK must be at least M, and should be
                     M*NB, where NB is the blocksize for this environment.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (4)
                     The test ratios compare two techniques for multiplying a
                     random matrix C by an n-by-n orthogonal matrix Q.
                     RESULT(1) = norm( Q*C - Q*C )  / ( N * norm(C) * EPS )
                     RESULT(2) = norm( C*Q - C*Q )  / ( N * norm(C) * EPS )
                     RESULT(3) = norm( Q'*C - Q'*C )/ ( N * norm(C) * EPS )
                     RESULT(4) = norm( C*Q' - C*Q' )/ ( N * norm(C) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zpbt01 (character UPLO, integer N, integer KD, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, double precision,
       dimension( * ) RWORK, double precision RESID)
       ZPBT01

       Purpose:

            ZPBT01 reconstructs a Hermitian positive definite band matrix A from
            its L*L' or U'*U factorization and computes the residual
               norm( L*L' - A ) / ( N * norm(A) * EPS ) or
               norm( U'*U - A ) / ( N * norm(A) * EPS ),
            where EPS is the machine epsilon, L' is the conjugate transpose of
            L, and U' is the conjugate transpose of U.

       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 number of rows and columns 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.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original Hermitian band matrix A.  If UPLO = 'U', the
                     upper triangular part of A is stored as a band matrix; if
                     UPLO = 'L', the lower triangular part of A is stored.  The
                     columns of the appropriate triangle are stored in the columns
                     of A and the diagonals of the triangle are stored in the rows
                     of A.  See ZPBTRF for further details.

           LDA

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

           AFAC

                     AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
                     The factored form of the matrix A.  AFAC contains the factor
                     L or U from the L*L' or U'*U factorization in band storage
                     format, as computed by ZPBTRF.

           LDAFAC

                     LDAFAC is INTEGER
                     The leading dimension of the array AFAC.
                     LDAFAC >= max(1,KD+1).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS )
                     If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zpbt02 (character UPLO, integer N, integer KD, integer NRHS, complex*16, dimension(
       lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
       dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double
       precision RESID)
       ZPBT02

       Purpose:

            ZPBT02 computes the residual for a solution of a Hermitian banded
            system of equations  A*x = b:
               RESID = norm( B - A*X ) / ( norm(A) * norm(X) * EPS)
            where EPS is the machine precision.

       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 number of rows and columns 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.

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides. NRHS >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original Hermitian band matrix A.  If UPLO = 'U', the
                     upper triangular part of A is stored as a band matrix; if
                     UPLO = 'L', the lower triangular part of A is stored.  The
                     columns of the appropriate triangle are stored in the columns
                     of A and the diagonals of the triangle are stored in the rows
                     of A.  See ZPBTRF for further details.

           LDA

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the right hand side vectors for the system of
                     linear equations.
                     On exit, B is overwritten with the difference B - A*X.

           LDB

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zpbt05 (character UPLO, integer N, integer KD, integer NRHS, complex*16, dimension(
       ldab, * ) AB, integer LDAB, complex*16, dimension( ldb, * ) B, integer LDB, complex*16,
       dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer
       LDXACT, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR,
       double precision, dimension( * ) RESLTS)
       ZPBT05

       Purpose:

            ZPBT05 tests the error bounds from iterative refinement for the
            computed solution to a system of equations A*X = B, where A is a
            Hermitian band matrix.

            RESLTS(1) = test of the error bound
                      = norm(X - XACT) / ( norm(X) * FERR )

            A large value is returned if this ratio is not less than one.

            RESLTS(2) = residual from the iterative refinement routine
                      = the maximum of BERR / ( NZ*EPS + (*) ), where
                        (*) = NZ*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
                        and NZ = max. number of nonzeros in any row of A, plus 1

       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 number of rows of the matrices X, B, and XACT, and 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.

           NRHS

                     NRHS is INTEGER
                     The number of columns of the matrices X, B, and XACT.
                     NRHS >= 0.

           AB

                     AB is COMPLEX*16 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.

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors.  Each vector is stored as a
                     column of the matrix X.

           LDX

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

           XACT

                     XACT is COMPLEX*16 array, dimension (LDX,NRHS)
                     The exact solution vectors.  Each vector is stored as a
                     column of the matrix XACT.

           LDXACT

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

           FERR

                     FERR is DOUBLE PRECISION array, dimension (NRHS)
                     The estimated forward error bounds for each solution vector
                     X.  If XTRUE is the true solution, FERR bounds the magnitude
                     of the largest entry in (X - XTRUE) divided by the magnitude
                     of the largest entry in X.

           BERR

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

           RESLTS

                     RESLTS is DOUBLE PRECISION array, dimension (2)
                     The maximum over the NRHS solution vectors of the ratios:
                     RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
                     RESLTS(2) = BERR / ( NZ*EPS + (*) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zpot01 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA,
       complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, double precision, dimension( * )
       RWORK, double precision RESID)
       ZPOT01

       Purpose:

            ZPOT01 reconstructs a Hermitian positive definite matrix  A  from
            its L*L' or U'*U factorization and computes the residual
               norm( L*L' - A ) / ( N * norm(A) * EPS ) or
               norm( U'*U - A ) / ( N * norm(A) * EPS ),
            where EPS is the machine epsilon, L' is the conjugate transpose of L,
            and U' is the conjugate transpose of U.

       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 number of rows and columns of the matrix A.  N >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original Hermitian matrix A.

           LDA

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

           AFAC

                     AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
                     On entry, the factor L or U from the L*L' or U'*U
                     factorization of A.
                     Overwritten with the reconstructed matrix, and then with the
                     difference L*L' - A (or U'*U - A).

           LDAFAC

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS )
                     If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zpot02 (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, *
       ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)
       ZPOT02

       Purpose:

            ZPOT02 computes the residual for the solution of a Hermitian system
            of linear equations  A*x = b:

               RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),

            where EPS is the machine epsilon.

       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 number of rows and columns of the matrix A.  N >= 0.

           NRHS

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

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original Hermitian matrix A.

           LDA

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the right hand side vectors for the system of
                     linear equations.
                     On exit, B is overwritten with the difference B - A*X.

           LDB

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zpot03 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA,
       complex*16, dimension( ldainv, * ) AINV, integer LDAINV, complex*16, dimension( ldwork, *
       ) WORK, integer LDWORK, double precision, dimension( * ) RWORK, double precision RCOND,
       double precision RESID)
       ZPOT03

       Purpose:

            ZPOT03 computes the residual for a Hermitian matrix times its
            inverse:
               norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ),
            where EPS is the machine epsilon.

       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 number of rows and columns of the matrix A.  N >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original Hermitian matrix A.

           LDA

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

           AINV

                     AINV is COMPLEX*16 array, dimension (LDAINV,N)
                     On entry, the inverse of the matrix A, stored as a Hermitian
                     matrix in the same format as A.
                     In this version, AINV is expanded into a full matrix and
                     multiplied by A, so the opposing triangle of AINV will be
                     changed; i.e., if the upper triangular part of AINV is
                     stored, the lower triangular part will be used as work space.

           LDAINV

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

           WORK

                     WORK is COMPLEX*16 array, dimension (LDWORK,N)

           LDWORK

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RCOND

                     RCOND is DOUBLE PRECISION
                     The reciprocal of the condition number of A, computed as
                     ( 1/norm(A) ) / norm(AINV).

           RESID

                     RESID is DOUBLE PRECISION
                     norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zpot05 (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, *
       ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double
       precision, dimension( * ) FERR, double precision, dimension( * ) BERR, double precision,
       dimension( * ) RESLTS)
       ZPOT05

       Purpose:

            ZPOT05 tests the error bounds from iterative refinement for the
            computed solution to a system of equations A*X = B, where A is a
            Hermitian n by n matrix.

            RESLTS(1) = test of the error bound
                      = norm(X - XACT) / ( norm(X) * FERR )

            A large value is returned if this ratio is not less than one.

            RESLTS(2) = residual from the iterative refinement routine
                      = the maximum of BERR / ( (n+1)*EPS + (*) ), where
                        (*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )

       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 number of rows of the matrices X, B, and XACT, and the
                     order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of columns of the matrices X, B, and XACT.
                     NRHS >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The Hermitian 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).

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors.  Each vector is stored as a
                     column of the matrix X.

           LDX

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

           XACT

                     XACT is COMPLEX*16 array, dimension (LDX,NRHS)
                     The exact solution vectors.  Each vector is stored as a
                     column of the matrix XACT.

           LDXACT

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

           FERR

                     FERR is DOUBLE PRECISION array, dimension (NRHS)
                     The estimated forward error bounds for each solution vector
                     X.  If XTRUE is the true solution, FERR bounds the magnitude
                     of the largest entry in (X - XTRUE) divided by the magnitude
                     of the largest entry in X.

           BERR

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

           RESLTS

                     RESLTS is DOUBLE PRECISION array, dimension (2)
                     The maximum over the NRHS solution vectors of the ratios:
                     RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
                     RESLTS(2) = BERR / ( (n+1)*EPS + (*) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zpot06 (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, *
       ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)
       ZPOT06

       Purpose:

            ZPOT06 computes the residual for a solution of a system of linear
            equations  A*x = b :
               RESID = norm(B - A*X,inf) / ( norm(A,inf) * norm(X,inf) * EPS ),
            where EPS is the machine epsilon.

       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 number of rows and columns of the matrix A.  N >= 0.

           NRHS

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

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original M x N matrix A.

           LDA

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  If TRANS = 'N',
                     LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,N).

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the right hand side vectors for the system of
                     linear equations.
                     On exit, B is overwritten with the difference B - A*X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  IF TRANS = 'N',
                     LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zppt01 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16,
       dimension( * ) AFAC, double precision, dimension( * ) RWORK, double precision RESID)
       ZPPT01

       Purpose:

            ZPPT01 reconstructs a Hermitian positive definite packed matrix A
            from its L*L' or U'*U factorization and computes the residual
               norm( L*L' - A ) / ( N * norm(A) * EPS ) or
               norm( U'*U - A ) / ( N * norm(A) * EPS ),
            where EPS is the machine epsilon, L' is the conjugate transpose of
            L, and U' is the conjugate transpose of U.

       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 number of rows and columns of the matrix A.  N >= 0.

           A

                     A is COMPLEX*16 array, dimension (N*(N+1)/2)
                     The original Hermitian matrix A, stored as a packed
                     triangular matrix.

           AFAC

                     AFAC is COMPLEX*16 array, dimension (N*(N+1)/2)
                     On entry, the factor L or U from the L*L' or U'*U
                     factorization of A, stored as a packed triangular matrix.
                     Overwritten with the reconstructed matrix, and then with the
                     difference L*L' - A (or U'*U - A).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS )
                     If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zppt02 (character UPLO, integer N, integer NRHS, complex*16, dimension( * ) A,
       complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer
       LDB, double precision, dimension( * ) RWORK, double precision RESID)
       ZPPT02

       Purpose:

            ZPPT02 computes the residual in the solution of a Hermitian system
            of linear equations  A*x = b  when packed storage is used for the
            coefficient matrix.  The ratio computed is

               RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS),

            where EPS is the machine precision.

       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 number of rows and columns of the matrix A.  N >= 0.

           NRHS

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

           A

                     A is COMPLEX*16 array, dimension (N*(N+1)/2)
                     The original Hermitian matrix A, stored as a packed
                     triangular matrix.

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the right hand side vectors for the system of
                     linear equations.
                     On exit, B is overwritten with the difference B - A*X.

           LDB

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zppt03 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16,
       dimension( * ) AINV, complex*16, dimension( ldwork, * ) WORK, integer LDWORK, double
       precision, dimension( * ) RWORK, double precision RCOND, double precision RESID)
       ZPPT03

       Purpose:

            ZPPT03 computes the residual for a Hermitian packed matrix times its
            inverse:
               norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ),
            where EPS is the machine epsilon.

       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 number of rows and columns of the matrix A.  N >= 0.

           A

                     A is COMPLEX*16 array, dimension (N*(N+1)/2)
                     The original Hermitian matrix A, stored as a packed
                     triangular matrix.

           AINV

                     AINV is COMPLEX*16 array, dimension (N*(N+1)/2)
                     The (Hermitian) inverse of the matrix A, stored as a packed
                     triangular matrix.

           WORK

                     WORK is COMPLEX*16 array, dimension (LDWORK,N)

           LDWORK

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RCOND

                     RCOND is DOUBLE PRECISION
                     The reciprocal of the condition number of A, computed as
                     ( 1/norm(A) ) / norm(AINV).

           RESID

                     RESID is DOUBLE PRECISION
                     norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zppt05 (character UPLO, integer N, integer NRHS, complex*16, dimension( * ) AP,
       complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer
       LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension(
       * ) FERR, double precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)
       ZPPT05

       Purpose:

            ZPPT05 tests the error bounds from iterative refinement for the
            computed solution to a system of equations A*X = B, where A is a
            Hermitian matrix in packed storage format.

            RESLTS(1) = test of the error bound
                      = norm(X - XACT) / ( norm(X) * FERR )

            A large value is returned if this ratio is not less than one.

            RESLTS(2) = residual from the iterative refinement routine
                      = the maximum of BERR / ( (n+1)*EPS + (*) ), where
                        (*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )

       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 number of rows of the matrices X, B, and XACT, and the
                     order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of columns of the matrices X, B, and XACT.
                     NRHS >= 0.

           AP

                     AP is COMPLEX*16 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.

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors.  Each vector is stored as a
                     column of the matrix X.

           LDX

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

           XACT

                     XACT is COMPLEX*16 array, dimension (LDX,NRHS)
                     The exact solution vectors.  Each vector is stored as a
                     column of the matrix XACT.

           LDXACT

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

           FERR

                     FERR is DOUBLE PRECISION array, dimension (NRHS)
                     The estimated forward error bounds for each solution vector
                     X.  If XTRUE is the true solution, FERR bounds the magnitude
                     of the largest entry in (X - XTRUE) divided by the magnitude
                     of the largest entry in X.

           BERR

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

           RESLTS

                     RESLTS is DOUBLE PRECISION array, dimension (2)
                     The maximum over the NRHS solution vectors of the ratios:
                     RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
                     RESLTS(2) = BERR / ( (n+1)*EPS + (*) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zpst01 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA,
       complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, complex*16, dimension( ldperm, *
       ) PERM, integer LDPERM, integer, dimension( * ) PIV, double precision, dimension( * )
       RWORK, double precision RESID, integer RANK)
       ZPST01

       Purpose:

            ZPST01 reconstructs an Hermitian positive semidefinite matrix A
            from its L or U factors and the permutation matrix P and computes
            the residual
               norm( P*L*L'*P' - A ) / ( N * norm(A) * EPS ) or
               norm( P*U'*U*P' - A ) / ( N * norm(A) * EPS ),
            where EPS is the machine epsilon, L' is the conjugate transpose of L,
            and U' is the conjugate transpose of U.

       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 number of rows and columns of the matrix A.  N >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original Hermitian matrix A.

           LDA

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

           AFAC

                     AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
                     The factor L or U from the L*L' or U'*U
                     factorization of A.

           LDAFAC

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

           PERM

                     PERM is COMPLEX*16 array, dimension (LDPERM,N)
                     Overwritten with the reconstructed matrix, and then with the
                     difference P*L*L'*P' - A (or P*U'*U*P' - A)

           LDPERM

                     LDPERM is INTEGER
                     The leading dimension of the array PERM.
                     LDAPERM >= max(1,N).

           PIV

                     PIV is INTEGER array, dimension (N)
                     PIV is such that the nonzero entries are
                     P( PIV( K ), K ) = 1.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS )
                     If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )

           RANK

                     RANK is INTEGER
                     number of nonzero singular values of A.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zptt01 (integer N, double precision, dimension( * ) D, complex*16, dimension( * )
       E, double precision, dimension( * ) DF, complex*16, dimension( * ) EF, complex*16,
       dimension( * ) WORK, double precision RESID)
       ZPTT01

       Purpose:

            ZPTT01 reconstructs a tridiagonal matrix A from its L*D*L'
            factorization and computes the residual
               norm(L*D*L' - A) / ( n * norm(A) * EPS ),
            where EPS is the machine epsilon.

       Parameters:
           N

                     N is INTEGTER
                     The order of the matrix A.

           D

                     D is DOUBLE PRECISION array, dimension (N)
                     The n diagonal elements of the tridiagonal matrix A.

           E

                     E is COMPLEX*16 array, dimension (N-1)
                     The (n-1) subdiagonal elements of the tridiagonal matrix A.

           DF

                     DF is DOUBLE PRECISION array, dimension (N)
                     The n diagonal elements of the factor L from the L*D*L'
                     factorization of A.

           EF

                     EF is COMPLEX*16 array, dimension (N-1)
                     The (n-1) subdiagonal elements of the factor L from the
                     L*D*L' factorization of A.

           WORK

                     WORK is COMPLEX*16 array, dimension (2*N)

           RESID

                     RESID is DOUBLE PRECISION
                     norm(L*D*L' - A) / (n * norm(A) * EPS)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zptt02 (character UPLO, integer N, integer NRHS, double precision, dimension( * )
       D, complex*16, dimension( * ) E, complex*16, dimension( ldx, * ) X, integer LDX,
       complex*16, dimension( ldb, * ) B, integer LDB, double precision RESID)
       ZPTT02

       Purpose:

            ZPTT02 computes the residual for the solution to a symmetric
            tridiagonal system of equations:
               RESID = norm(B - A*X) / (norm(A) * norm(X) * EPS),
            where EPS is the machine epsilon.

       Parameters:
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the superdiagonal or the subdiagonal of the
                     tridiagonal matrix A is stored.
                     = 'U':  E is the superdiagonal of A
                     = 'L':  E is the subdiagonal of A

           N

                     N is INTEGTER
                     The order of the matrix A.

           NRHS

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

           D

                     D is DOUBLE PRECISION array, dimension (N)
                     The n diagonal elements of the tridiagonal matrix A.

           E

                     E is COMPLEX*16 array, dimension (N-1)
                     The (n-1) subdiagonal elements of the tridiagonal matrix A.

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The n by nrhs matrix of solution vectors X.

           LDX

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the n by nrhs matrix of right hand side vectors B.
                     On exit, B is overwritten with the difference B - A*X.

           LDB

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

           RESID

                     RESID is DOUBLE PRECISION
                     norm(B - A*X) / (norm(A) * norm(X) * EPS)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zptt05 (integer N, integer NRHS, double precision, dimension( * ) D, complex*16,
       dimension( * ) E, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension(
       ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double
       precision, dimension( * ) FERR, double precision, dimension( * ) BERR, double precision,
       dimension( * ) RESLTS)
       ZPTT05

       Purpose:

            ZPTT05 tests the error bounds from iterative refinement for the
            computed solution to a system of equations A*X = B, where A is a
            Hermitian tridiagonal matrix of order n.

            RESLTS(1) = test of the error bound
                      = norm(X - XACT) / ( norm(X) * FERR )

            A large value is returned if this ratio is not less than one.

            RESLTS(2) = residual from the iterative refinement routine
                      = the maximum of BERR / ( NZ*EPS + (*) ), where
                        (*) = NZ*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
                        and NZ = max. number of nonzeros in any row of A, plus 1

       Parameters:
           N

                     N is INTEGER
                     The number of rows of the matrices X, B, and XACT, and the
                     order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of columns of the matrices X, B, and XACT.
                     NRHS >= 0.

           D

                     D is DOUBLE PRECISION array, dimension (N)
                     The n diagonal elements of the tridiagonal matrix A.

           E

                     E is COMPLEX*16 array, dimension (N-1)
                     The (n-1) subdiagonal elements of the tridiagonal matrix A.

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors.  Each vector is stored as a
                     column of the matrix X.

           LDX

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

           XACT

                     XACT is COMPLEX*16 array, dimension (LDX,NRHS)
                     The exact solution vectors.  Each vector is stored as a
                     column of the matrix XACT.

           LDXACT

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

           FERR

                     FERR is DOUBLE PRECISION array, dimension (NRHS)
                     The estimated forward error bounds for each solution vector
                     X.  If XTRUE is the true solution, FERR bounds the magnitude
                     of the largest entry in (X - XTRUE) divided by the magnitude
                     of the largest entry in X.

           BERR

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

           RESLTS

                     RESLTS is DOUBLE PRECISION array, dimension (2)
                     The maximum over the NRHS solution vectors of the ratios:
                     RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
                     RESLTS(2) = BERR / ( NZ*EPS + (*) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zqlt01 (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16,
       dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * )
       L, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK,
       integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * )
       RESULT)
       ZQLT01

       Purpose:

            ZQLT01 tests ZGEQLF, which computes the QL factorization of an m-by-n
            matrix A, and partially tests ZUNGQL which forms the m-by-m
            orthogonal matrix Q.

            ZQLT01 compares L with Q'*A, and checks that Q is orthogonal.

       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.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The m-by-n matrix A.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the QL factorization of A, as returned by ZGEQLF.
                     See ZGEQLF for further details.

           Q

                     Q is COMPLEX*16 array, dimension (LDA,M)
                     The m-by-m orthogonal matrix Q.

           L

                     L is COMPLEX*16 array, dimension (LDA,max(M,N))

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A, AF, Q and R.
                     LDA >= max(M,N).

           TAU

                     TAU is COMPLEX*16 array, dimension (min(M,N))
                     The scalar factors of the elementary reflectors, as returned
                     by ZGEQLF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The test ratios:
                     RESULT(1) = norm( L - Q'*A ) / ( M * norm(A) * EPS )
                     RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zqlt02 (integer M, integer N, integer K, complex*16, dimension( lda, * ) A,
       complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16,
       dimension( lda, * ) L, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
       lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
       dimension( * ) RESULT)
       ZQLT02

       Purpose:

            ZQLT02 tests ZUNGQL, which generates an m-by-n matrix Q with
            orthonornmal columns that is defined as the product of k elementary
            reflectors.

            Given the QL factorization of an m-by-n matrix A, ZQLT02 generates
            the orthogonal matrix Q defined by the factorization of the last k
            columns of A; it compares L(m-n+1:m,n-k+1:n) with
            Q(1:m,m-n+1:m)'*A(1:m,n-k+1:n), and checks that the columns of Q are
            orthonormal.

       Parameters:
           M

                     M is INTEGER
                     The number of rows of the matrix Q to be generated.  M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix Q to be generated.
                     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*16 array, dimension (LDA,N)
                     The m-by-n matrix A which was factorized by ZQLT01.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the QL factorization of A, as returned by ZGEQLF.
                     See ZGEQLF for further details.

           Q

                     Q is COMPLEX*16 array, dimension (LDA,N)

           L

                     L is COMPLEX*16 array, dimension (LDA,N)

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A, AF, Q and L. LDA >= M.

           TAU

                     TAU is COMPLEX*16 array, dimension (N)
                     The scalar factors of the elementary reflectors corresponding
                     to the QL factorization in AF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The test ratios:
                     RESULT(1) = norm( L - Q'*A ) / ( M * norm(A) * EPS )
                     RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zqlt03 (integer M, integer N, integer K, complex*16, dimension( lda, * ) AF,
       complex*16, dimension( lda, * ) C, complex*16, dimension( lda, * ) CC, complex*16,
       dimension( lda, * ) Q, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
       lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
       dimension( * ) RESULT)
       ZQLT03

       Purpose:

            ZQLT03 tests ZUNMQL, which computes Q*C, Q'*C, C*Q or C*Q'.

            ZQLT03 compares the results of a call to ZUNMQL with the results of
            forming Q explicitly by a call to ZUNGQL and then performing matrix
            multiplication by a call to ZGEMM.

       Parameters:
           M

                     M is INTEGER
                     The order of the orthogonal matrix Q.  M >= 0.

           N

                     N is INTEGER
                     The number of rows or columns of the matrix C; C is m-by-n if
                     Q is applied from the left, or n-by-m if Q is applied from
                     the right.  N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     orthogonal matrix Q.  M >= K >= 0.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the QL factorization of an m-by-n matrix, as
                     returned by ZGEQLF. See CGEQLF for further details.

           C

                     C is COMPLEX*16 array, dimension (LDA,N)

           CC

                     CC is COMPLEX*16 array, dimension (LDA,N)

           Q

                     Q is COMPLEX*16 array, dimension (LDA,M)

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays AF, C, CC, and Q.

           TAU

                     TAU is COMPLEX*16 array, dimension (min(M,N))
                     The scalar factors of the elementary reflectors corresponding
                     to the QL factorization in AF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of WORK.  LWORK must be at least M, and should be
                     M*NB, where NB is the blocksize for this environment.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (4)
                     The test ratios compare two techniques for multiplying a
                     random matrix C by an m-by-m orthogonal matrix Q.
                     RESULT(1) = norm( Q*C - Q*C )  / ( M * norm(C) * EPS )
                     RESULT(2) = norm( C*Q - C*Q )  / ( M * norm(C) * EPS )
                     RESULT(3) = norm( Q'*C - Q'*C )/ ( M * norm(C) * EPS )
                     RESULT(4) = norm( C*Q' - C*Q' )/ ( M * norm(C) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   double precision function zqpt01 (integer M, integer N, integer K, complex*16, dimension( lda,
       * ) A, complex*16, dimension( lda, * ) AF, integer LDA, complex*16, dimension( * ) TAU,
       integer, dimension( * ) JPVT, complex*16, dimension( lwork ) WORK, integer LWORK)
       ZQPT01

       Purpose:

            ZQPT01 tests the QR-factorization with pivoting of a matrix A.  The
            array AF contains the (possibly partial) QR-factorization of A, where
            the upper triangle of AF(1:k,1:k) is a partial triangular factor,
            the entries below the diagonal in the first k columns are the
            Householder vectors, and the rest of AF contains a partially updated
            matrix.

            This function returns ||A*P - Q*R||/(||norm(A)||*eps*M)

       Parameters:
           M

                     M is INTEGER
                     The number of rows of the matrices A and AF.

           N

                     N is INTEGER
                     The number of columns of the matrices A and AF.

           K

                     K is INTEGER
                     The number of columns of AF that have been reduced
                     to upper triangular form.

           A

                     A is COMPLEX*16 array, dimension (LDA, N)
                     The original matrix A.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     The (possibly partial) output of ZGEQPF.  The upper triangle
                     of AF(1:k,1:k) is a partial triangular factor, the entries
                     below the diagonal in the first k columns are the Householder
                     vectors, and the rest of AF contains a partially updated
                     matrix.

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A and AF.

           TAU

                     TAU is COMPLEX*16 array, dimension (K)
                     Details of the Householder transformations as returned by
                     ZGEQPF.

           JPVT

                     JPVT is INTEGER array, dimension (N)
                     Pivot information as returned by ZGEQPF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of the array WORK.  LWORK >= M*N+N.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zqrt01 (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16,
       dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * )
       R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK,
       integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * )
       RESULT)
       ZQRT01

       Purpose:

            ZQRT01 tests ZGEQRF, which computes the QR factorization of an m-by-n
            matrix A, and partially tests ZUNGQR which forms the m-by-m
            orthogonal matrix Q.

            ZQRT01 compares R with Q'*A, and checks that Q is orthogonal.

       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.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The m-by-n matrix A.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the QR factorization of A, as returned by ZGEQRF.
                     See ZGEQRF for further details.

           Q

                     Q is COMPLEX*16 array, dimension (LDA,M)
                     The m-by-m orthogonal matrix Q.

           R

                     R is COMPLEX*16 array, dimension (LDA,max(M,N))

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A, AF, Q and R.
                     LDA >= max(M,N).

           TAU

                     TAU is COMPLEX*16 array, dimension (min(M,N))
                     The scalar factors of the elementary reflectors, as returned
                     by ZGEQRF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The test ratios:
                     RESULT(1) = norm( R - Q'*A ) / ( M * norm(A) * EPS )
                     RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zqrt01p (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16,
       dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * )
       R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK,
       integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * )
       RESULT)
       ZQRT01P

       Purpose:

            ZQRT01P tests ZGEQRFP, which computes the QR factorization of an m-by-n
            matrix A, and partially tests ZUNGQR which forms the m-by-m
            orthogonal matrix Q.

            ZQRT01P compares R with Q'*A, and checks that Q is orthogonal.

       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.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The m-by-n matrix A.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the QR factorization of A, as returned by ZGEQRFP.
                     See ZGEQRFP for further details.

           Q

                     Q is COMPLEX*16 array, dimension (LDA,M)
                     The m-by-m orthogonal matrix Q.

           R

                     R is COMPLEX*16 array, dimension (LDA,max(M,N))

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A, AF, Q and R.
                     LDA >= max(M,N).

           TAU

                     TAU is COMPLEX*16 array, dimension (min(M,N))
                     The scalar factors of the elementary reflectors, as returned
                     by ZGEQRFP.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The test ratios:
                     RESULT(1) = norm( R - Q'*A ) / ( M * norm(A) * EPS )
                     RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zqrt02 (integer M, integer N, integer K, complex*16, dimension( lda, * ) A,
       complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16,
       dimension( lda, * ) R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
       lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
       dimension( * ) RESULT)
       ZQRT02

       Purpose:

            ZQRT02 tests ZUNGQR, which generates an m-by-n matrix Q with
            orthonornmal columns that is defined as the product of k elementary
            reflectors.

            Given the QR factorization of an m-by-n matrix A, ZQRT02 generates
            the orthogonal matrix Q defined by the factorization of the first k
            columns of A; it compares R(1:n,1:k) with Q(1:m,1:n)'*A(1:m,1:k),
            and checks that the columns of Q are orthonormal.

       Parameters:
           M

                     M is INTEGER
                     The number of rows of the matrix Q to be generated.  M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix Q to be generated.
                     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*16 array, dimension (LDA,N)
                     The m-by-n matrix A which was factorized by ZQRT01.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the QR factorization of A, as returned by ZGEQRF.
                     See ZGEQRF for further details.

           Q

                     Q is COMPLEX*16 array, dimension (LDA,N)

           R

                     R is COMPLEX*16 array, dimension (LDA,N)

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A, AF, Q and R. LDA >= M.

           TAU

                     TAU is COMPLEX*16 array, dimension (N)
                     The scalar factors of the elementary reflectors corresponding
                     to the QR factorization in AF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The test ratios:
                     RESULT(1) = norm( R - Q'*A ) / ( M * norm(A) * EPS )
                     RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zqrt03 (integer M, integer N, integer K, complex*16, dimension( lda, * ) AF,
       complex*16, dimension( lda, * ) C, complex*16, dimension( lda, * ) CC, complex*16,
       dimension( lda, * ) Q, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
       lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
       dimension( * ) RESULT)
       ZQRT03

       Purpose:

            ZQRT03 tests ZUNMQR, which computes Q*C, Q'*C, C*Q or C*Q'.

            ZQRT03 compares the results of a call to ZUNMQR with the results of
            forming Q explicitly by a call to ZUNGQR and then performing matrix
            multiplication by a call to ZGEMM.

       Parameters:
           M

                     M is INTEGER
                     The order of the orthogonal matrix Q.  M >= 0.

           N

                     N is INTEGER
                     The number of rows or columns of the matrix C; C is m-by-n if
                     Q is applied from the left, or n-by-m if Q is applied from
                     the right.  N >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     orthogonal matrix Q.  M >= K >= 0.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the QR factorization of an m-by-n matrix, as
                     returned by ZGEQRF. See ZGEQRF for further details.

           C

                     C is COMPLEX*16 array, dimension (LDA,N)

           CC

                     CC is COMPLEX*16 array, dimension (LDA,N)

           Q

                     Q is COMPLEX*16 array, dimension (LDA,M)

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays AF, C, CC, and Q.

           TAU

                     TAU is COMPLEX*16 array, dimension (min(M,N))
                     The scalar factors of the elementary reflectors corresponding
                     to the QR factorization in AF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of WORK.  LWORK must be at least M, and should be
                     M*NB, where NB is the blocksize for this environment.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (4)
                     The test ratios compare two techniques for multiplying a
                     random matrix C by an m-by-m orthogonal matrix Q.
                     RESULT(1) = norm( Q*C - Q*C )  / ( M * norm(C) * EPS )
                     RESULT(2) = norm( C*Q - C*Q )  / ( M * norm(C) * EPS )
                     RESULT(3) = norm( Q'*C - Q'*C )/ ( M * norm(C) * EPS )
                     RESULT(4) = norm( C*Q' - C*Q' )/ ( M * norm(C) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zqrt04 (integer M, integer N, integer NB, double precision, dimension(6) RESULT)
       ZQRT04

       Purpose:

            ZQRT04 tests ZGEQRT and ZGEMQRT.

       Parameters:
           M

                     M is INTEGER
                     Number of rows in test matrix.

           N

                     N is INTEGER
                     Number of columns in test matrix.

           NB

                     NB is INTEGER
                     Block size of test matrix.  NB <= Min(M,N).

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (6)
                     Results of each of the six tests below.

                     RESULT(1) = | A - Q R |
                     RESULT(2) = | I - Q^H Q |
                     RESULT(3) = | Q C - Q C |
                     RESULT(4) = | Q^H C - Q^H C |
                     RESULT(5) = | C Q - C Q |
                     RESULT(6) = | C Q^H - C Q^H |

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           April 2012

   subroutine zqrt05 (integer M, integer N, integer L, integer NB, double precision, dimension(6)
       RESULT)
       ZQRT05

       Purpose:

            ZQRT05 tests ZTPQRT and ZTPMQRT.

       Parameters:
           M

                     M is INTEGER
                     Number of rows in lower part of the test matrix.

           N

                     N is INTEGER
                     Number of columns in test matrix.

           L

                     L is INTEGER
                     The number of rows of the upper trapezoidal part the
                     lower test matrix.  0 <= L <= M.

           NB

                     NB is INTEGER
                     Block size of test matrix.  NB <= N.

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (6)
                     Results of each of the six tests below.

                     RESULT(1) = | A - Q R |
                     RESULT(2) = | I - Q^H Q |
                     RESULT(3) = | Q C - Q C |
                     RESULT(4) = | Q^H C - Q^H C |
                     RESULT(5) = | C Q - C Q |
                     RESULT(6) = | C Q^H - C Q^H |

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           April 2012

   double precision function zqrt11 (integer M, integer K, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer
       LWORK)
       ZQRT11

       Purpose:

            ZQRT11 computes the test ratio

                  || Q'*Q - I || / (eps * m)

            where the orthogonal matrix Q is represented as a product of
            elementary transformations.  Each transformation has the form

               H(k) = I - tau(k) v(k) v(k)'

            where tau(k) is stored in TAU(k) and v(k) is an m-vector of the form
            [ 0 ... 0 1 x(k) ]', where x(k) is a vector of length m-k stored
            in A(k+1:m,k).

       Parameters:
           M

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

           K

                     K is INTEGER
                     The number of columns of A whose subdiagonal entries
                     contain information about orthogonal transformations.

           A

                     A is COMPLEX*16 array, dimension (LDA,K)
                     The (possibly partial) output of a QR reduction routine.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.

           TAU

                     TAU is COMPLEX*16 array, dimension (K)
                     The scaling factors tau for the elementary transformations as
                     computed by the QR factorization routine.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of the array WORK.  LWORK >= M*M + M.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   double precision function zqrt12 (integer M, integer N, complex*16, dimension( lda, * ) A,
       integer LDA, double precision, dimension( * ) S, complex*16, dimension( lwork ) WORK,
       integer LWORK, double precision, dimension( * ) RWORK)
       ZQRT12

       Purpose:

            ZQRT12 computes the singular values `svlues' of the upper trapezoid
            of A(1:M,1:N) and returns the ratio

                 || s - svlues||/(||svlues||*eps*max(M,N))

       Parameters:
           M

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

           N

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

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The M-by-N matrix A. Only the upper trapezoid is referenced.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.

           S

                     S is DOUBLE PRECISION array, dimension (min(M,N))
                     The singular values of the matrix A.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of the array WORK. LWORK >= M*N + 2*min(M,N) +
                     max(M,N).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (2*min(M,N))

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zqrt13 (integer SCALE, integer M, integer N, complex*16, dimension( lda, * ) A,
       integer LDA, double precision NORMA, integer, dimension( 4 ) ISEED)
       ZQRT13

       Purpose:

            ZQRT13 generates a full-rank matrix that may be scaled to have large
            or small norm.

       Parameters:
           SCALE

                     SCALE is INTEGER
                     SCALE = 1: normally scaled matrix
                     SCALE = 2: matrix scaled up
                     SCALE = 3: matrix scaled down

           M

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

           N

                     N is INTEGER
                     The number of columns of A.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The M-by-N matrix A.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.

           NORMA

                     NORMA is DOUBLE PRECISION
                     The one-norm of A.

           ISEED

                     ISEED is integer array, dimension (4)
                     Seed for random number generator

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   double precision function zqrt14 (character TRANS, integer M, integer N, integer NRHS,
       complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer
       LDX, complex*16, dimension( lwork ) WORK, integer LWORK)
       ZQRT14

       Purpose:

            ZQRT14 checks whether X is in the row space of A or A'.  It does so
            by scaling both X and A such that their norms are in the range
            [sqrt(eps), 1/sqrt(eps)], then computing a QR factorization of [A,X]
            (if TRANS = 'C') or an LQ factorization of [A',X]' (if TRANS = 'N'),
            and returning the norm of the trailing triangle, scaled by
            MAX(M,N,NRHS)*eps.

       Parameters:
           TRANS

                     TRANS is CHARACTER*1
                     = 'N':  No transpose, check for X in the row space of A
                     = 'C':  Conjugate transpose, check for X in row space of A'.

           M

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

           N

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

           NRHS

                     NRHS is INTEGER
                     The number of right hand sides, i.e., the number of columns
                     of X.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The M-by-N matrix A.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     If TRANS = 'N', the N-by-NRHS matrix X.
                     IF TRANS = 'C', the M-by-NRHS matrix X.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.

           WORK

                     WORK is COMPLEX*16 array dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     length of workspace array required
                     If TRANS = 'N', LWORK >= (M+NRHS)*(N+2);
                     if TRANS = 'C', LWORK >= (N+NRHS)*(M+2).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zqrt15 (integer SCALE, integer RKSEL, integer M, integer N, integer NRHS,
       complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B, integer
       LDB, double precision, dimension( * ) S, integer RANK, double precision NORMA, double
       precision NORMB, integer, dimension( 4 ) ISEED, complex*16, dimension( lwork ) WORK,
       integer LWORK)
       ZQRT15

       Purpose:

            ZQRT15 generates a matrix with full or deficient rank and of various
            norms.

       Parameters:
           SCALE

                     SCALE is INTEGER
                     SCALE = 1: normally scaled matrix
                     SCALE = 2: matrix scaled up
                     SCALE = 3: matrix scaled down

           RKSEL

                     RKSEL is INTEGER
                     RKSEL = 1: full rank matrix
                     RKSEL = 2: rank-deficient matrix

           M

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

           N

                     N is INTEGER
                     The number of columns of A.

           NRHS

                     NRHS is INTEGER
                     The number of columns of B.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The M-by-N matrix A.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.

           B

                     B is COMPLEX*16 array, dimension (LDB, NRHS)
                     A matrix that is in the range space of matrix A.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.

           S

                     S is DOUBLE PRECISION array, dimension MIN(M,N)
                     Singular values of A.

           RANK

                     RANK is INTEGER
                     number of nonzero singular values of A.

           NORMA

                     NORMA is DOUBLE PRECISION
                     one-norm norm of A.

           NORMB

                     NORMB is DOUBLE PRECISION
                     one-norm norm of B.

           ISEED

                     ISEED is integer array, dimension (4)
                     seed for random number generator.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     length of work space required.
                     LWORK >= MAX(M+MIN(M,N),NRHS*MIN(M,N),2*N+M)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zqrt16 (character TRANS, integer M, integer N, integer NRHS, complex*16, dimension(
       lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
       dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double
       precision RESID)
       ZQRT16

       Purpose:

            ZQRT16 computes the residual for a solution of a system of linear
            equations  A*x = b  or  A'*x = b:
               RESID = norm(B - A*X) / ( max(m,n) * norm(A) * norm(X) * EPS ),
            where EPS is the machine epsilon.

       Parameters:
           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations:
                     = 'N':  A *x = b
                     = 'T':  A^T*x = b, where A^T is the transpose of A
                     = 'C':  A^H*x = b, where A^H is the conjugate transpose of A

           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.

           NRHS

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

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original M x N matrix A.

           LDA

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  If TRANS = 'N',
                     LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the right hand side vectors for the system of
                     linear equations.
                     On exit, B is overwritten with the difference B - A*X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  IF TRANS = 'N',
                     LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(B - A*X) / ( max(m,n) * norm(A) * norm(X) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   double precision function zqrt17 (character TRANS, integer IRESID, integer M, integer N,
       integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx,
       * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension(
       ldb, * ) C, complex*16, dimension( lwork ) WORK, integer LWORK)
       ZQRT17

       Purpose:

            ZQRT17 computes the ratio

               || R'*op(A) ||/(||A||*alpha*max(M,N,NRHS)*eps)

            where R = op(A)*X - B, op(A) is A or A', and

               alpha = ||B|| if IRESID = 1 (zero-residual problem)
               alpha = ||R|| if IRESID = 2 (otherwise).

       Parameters:
           TRANS

                     TRANS is CHARACTER*1
                     Specifies whether or not the transpose of A is used.
                     = 'N':  No transpose, op(A) = A.
                     = 'C':  Conjugate transpose, op(A) = A'.

           IRESID

                     IRESID is INTEGER
                     IRESID = 1 indicates zero-residual problem.
                     IRESID = 2 indicates non-zero residual.

           M

                     M is INTEGER
                     The number of rows of the matrix A.
                     If TRANS = 'N', the number of rows of the matrix B.
                     If TRANS = 'C', the number of rows of the matrix X.

           N

                     N is INTEGER
                     The number of columns of the matrix  A.
                     If TRANS = 'N', the number of rows of the matrix X.
                     If TRANS = 'C', the number of rows of the matrix B.

           NRHS

                     NRHS is INTEGER
                     The number of columns of the matrices X and B.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The m-by-n matrix A.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A. LDA >= M.

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     If TRANS = 'N', the n-by-nrhs matrix X.
                     If TRANS = 'C', the m-by-nrhs matrix X.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.
                     If TRANS = 'N', LDX >= N.
                     If TRANS = 'C', LDX >= M.

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     If TRANS = 'N', the m-by-nrhs matrix B.
                     If TRANS = 'C', the n-by-nrhs matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.
                     If TRANS = 'N', LDB >= M.
                     If TRANS = 'C', LDB >= N.

           C

                     C is COMPLEX*16 array, dimension (LDB,NRHS)

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of the array WORK.  LWORK >= NRHS*(M+N).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zrqt01 (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16,
       dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * )
       R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK,
       integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * )
       RESULT)
       ZRQT01

       Purpose:

            ZRQT01 tests ZGERQF, which computes the RQ factorization of an m-by-n
            matrix A, and partially tests ZUNGRQ which forms the n-by-n
            orthogonal matrix Q.

            ZRQT01 compares R with A*Q', and checks that Q is orthogonal.

       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.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The m-by-n matrix A.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the RQ factorization of A, as returned by ZGERQF.
                     See ZGERQF for further details.

           Q

                     Q is COMPLEX*16 array, dimension (LDA,N)
                     The n-by-n orthogonal matrix Q.

           R

                     R is COMPLEX*16 array, dimension (LDA,max(M,N))

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A, AF, Q and L.
                     LDA >= max(M,N).

           TAU

                     TAU is COMPLEX*16 array, dimension (min(M,N))
                     The scalar factors of the elementary reflectors, as returned
                     by ZGERQF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (max(M,N))

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The test ratios:
                     RESULT(1) = norm( R - A*Q' ) / ( N * norm(A) * EPS )
                     RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zrqt02 (integer M, integer N, integer K, complex*16, dimension( lda, * ) A,
       complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16,
       dimension( lda, * ) R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
       lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
       dimension( * ) RESULT)
       ZRQT02

       Purpose:

            ZRQT02 tests ZUNGRQ, which generates an m-by-n matrix Q with
            orthonornmal rows that is defined as the product of k elementary
            reflectors.

            Given the RQ factorization of an m-by-n matrix A, ZRQT02 generates
            the orthogonal matrix Q defined by the factorization of the last k
            rows of A; it compares R(m-k+1:m,n-m+1:n) with
            A(m-k+1:m,1:n)*Q(n-m+1:n,1:n)', and checks that the rows of Q are
            orthonormal.

       Parameters:
           M

                     M is INTEGER
                     The number of rows of the matrix Q to be generated.  M >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrix Q to be generated.
                     N >= M >= 0.

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     matrix Q. M >= K >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The m-by-n matrix A which was factorized by ZRQT01.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the RQ factorization of A, as returned by ZGERQF.
                     See ZGERQF for further details.

           Q

                     Q is COMPLEX*16 array, dimension (LDA,N)

           R

                     R is COMPLEX*16 array, dimension (LDA,M)

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A, AF, Q and L. LDA >= N.

           TAU

                     TAU is COMPLEX*16 array, dimension (M)
                     The scalar factors of the elementary reflectors corresponding
                     to the RQ factorization in AF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The test ratios:
                     RESULT(1) = norm( R - A*Q' ) / ( N * norm(A) * EPS )
                     RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zrqt03 (integer M, integer N, integer K, complex*16, dimension( lda, * ) AF,
       complex*16, dimension( lda, * ) C, complex*16, dimension( lda, * ) CC, complex*16,
       dimension( lda, * ) Q, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
       lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
       dimension( * ) RESULT)
       ZRQT03

       Purpose:

            ZRQT03 tests ZUNMRQ, which computes Q*C, Q'*C, C*Q or C*Q'.

            ZRQT03 compares the results of a call to ZUNMRQ with the results of
            forming Q explicitly by a call to ZUNGRQ and then performing matrix
            multiplication by a call to ZGEMM.

       Parameters:
           M

                     M is INTEGER
                     The number of rows or columns of the matrix C; C is n-by-m if
                     Q is applied from the left, or m-by-n if Q is applied from
                     the right.  M >= 0.

           N

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

           K

                     K is INTEGER
                     The number of elementary reflectors whose product defines the
                     orthogonal matrix Q.  N >= K >= 0.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the RQ factorization of an m-by-n matrix, as
                     returned by ZGERQF. See CGERQF for further details.

           C

                     C is COMPLEX*16 array, dimension (LDA,N)

           CC

                     CC is COMPLEX*16 array, dimension (LDA,N)

           Q

                     Q is COMPLEX*16 array, dimension (LDA,N)

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays AF, C, CC, and Q.

           TAU

                     TAU is COMPLEX*16 array, dimension (min(M,N))
                     The scalar factors of the elementary reflectors corresponding
                     to the RQ factorization in AF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of WORK.  LWORK must be at least M, and should be
                     M*NB, where NB is the blocksize for this environment.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (4)
                     The test ratios compare two techniques for multiplying a
                     random matrix C by an n-by-n orthogonal matrix Q.
                     RESULT(1) = norm( Q*C - Q*C )  / ( N * norm(C) * EPS )
                     RESULT(2) = norm( C*Q - C*Q )  / ( N * norm(C) * EPS )
                     RESULT(3) = norm( Q'*C - Q'*C )/ ( N * norm(C) * EPS )
                     RESULT(4) = norm( C*Q' - C*Q' )/ ( N * norm(C) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   double precision function zrzt01 (integer M, integer N, complex*16, dimension( lda, * ) A,
       complex*16, dimension( lda, * ) AF, integer LDA, complex*16, dimension( * ) TAU,
       complex*16, dimension( lwork ) WORK, integer LWORK)
       ZRZT01

       Purpose:

            ZRZT01 returns
                 || A - R*Q || / ( M * eps * ||A|| )
            for an upper trapezoidal A that was factored with ZTZRZF.

       Parameters:
           M

                     M is INTEGER
                     The number of rows of the matrices A and AF.

           N

                     N is INTEGER
                     The number of columns of the matrices A and AF.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original upper trapezoidal M by N matrix A.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     The output of ZTZRZF for input matrix A.
                     The lower triangle is not referenced.

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A and AF.

           TAU

                     TAU is COMPLEX*16 array, dimension (M)
                     Details of the  Householder transformations as returned by
                     ZTZRZF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of the array WORK.  LWORK >= m*n + m.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   double precision function zrzt02 (integer M, integer N, complex*16, dimension( lda, * ) AF,
       integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer
       LWORK)
       ZRZT02

       Purpose:

            ZRZT02 returns
                 || I - Q'*Q || / ( M * eps)
            where the matrix Q is defined by the Householder transformations
            generated by ZTZRZF.

       Parameters:
           M

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

           N

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

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     The output of ZTZRZF.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array AF.

           TAU

                     TAU is COMPLEX*16 array, dimension (M)
                     Details of the Householder transformations as returned by
                     ZTZRZF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     Length of WORK array. LWORK >= N*N+N.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zsbmv (character UPLO, integer N, integer K, complex*16 ALPHA, complex*16,
       dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) X, integer INCX, complex*16
       BETA, complex*16, dimension( * ) Y, integer INCY)
       ZSBMV

       Purpose:

            ZSBMV  performs the matrix-vector  operation

               y := alpha*A*x + beta*y,

            where alpha and beta are scalars, x and y are n element vectors and
            A is an n by n symmetric band matrix, with k super-diagonals.

             UPLO   - CHARACTER*1
                      On entry, UPLO specifies whether the upper or lower
                      triangular part of the band matrix A is being supplied as
                      follows:

                         UPLO = 'U' or 'u'   The upper triangular part of A is
                                             being supplied.

                         UPLO = 'L' or 'l'   The lower triangular part of A is
                                             being supplied.

                      Unchanged on exit.

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

             K      - INTEGER
                      On entry, K specifies the number of super-diagonals of the
                      matrix A. K must satisfy  0 .le. K.
                      Unchanged on exit.

             ALPHA  - COMPLEX*16
                      On entry, ALPHA specifies the scalar alpha.
                      Unchanged on exit.

             A      - COMPLEX*16 array, dimension( LDA, N )
                      Before entry with UPLO = 'U' or 'u', the leading ( k + 1 )
                      by n part of the array A must contain the upper triangular
                      band part of the symmetric matrix, supplied column by
                      column, with the leading diagonal of the matrix in row
                      ( k + 1 ) of the array, the first super-diagonal starting at
                      position 2 in row k, and so on. The top left k by k triangle
                      of the array A is not referenced.
                      The following program segment will transfer the upper
                      triangular part of a symmetric band matrix from conventional
                      full matrix storage to band storage:

                            DO 20, J = 1, N
                               M = K + 1 - J
                               DO 10, I = MAX( 1, J - K ), J
                                  A( M + I, J ) = matrix( I, J )
                         10    CONTINUE
                         20 CONTINUE

                      Before entry with UPLO = 'L' or 'l', the leading ( k + 1 )
                      by n part of the array A must contain the lower triangular
                      band part of the symmetric matrix, supplied column by
                      column, with the leading diagonal of the matrix in row 1 of
                      the array, the first sub-diagonal starting at position 1 in
                      row 2, and so on. The bottom right k by k triangle of the
                      array A is not referenced.
                      The following program segment will transfer the lower
                      triangular part of a symmetric band matrix from conventional
                      full matrix storage to band storage:

                            DO 20, J = 1, N
                               M = 1 - J
                               DO 10, I = J, MIN( N, J + K )
                                  A( M + I, J ) = matrix( I, J )
                         10    CONTINUE
                         20 CONTINUE

                      Unchanged on exit.

             LDA    - INTEGER
                      On entry, LDA specifies the first dimension of A as declared
                      in the calling (sub) program. LDA must be at least
                      ( k + 1 ).
                      Unchanged on exit.

             X      - COMPLEX*16 array, dimension at least
                      ( 1 + ( N - 1 )*abs( INCX ) ).
                      Before entry, the incremented array X must contain the
                      vector x.
                      Unchanged on exit.

             INCX   - INTEGER
                      On entry, INCX specifies the increment for the elements of
                      X. INCX must not be zero.
                      Unchanged on exit.

             BETA   - COMPLEX*16
                      On entry, BETA specifies the scalar beta.
                      Unchanged on exit.

             Y      - COMPLEX*16 array, dimension at least
                      ( 1 + ( N - 1 )*abs( INCY ) ).
                      Before entry, the incremented array Y must contain the
                      vector y. On exit, Y is overwritten by the updated vector y.

             INCY   - INTEGER
                      On entry, INCY specifies the increment for the elements of
                      Y. INCY must not be zero.
                      Unchanged on exit.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zspt01 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16,
       dimension( * ) AFAC, integer, dimension( * ) IPIV, complex*16, dimension( ldc, * ) C,
       integer LDC, double precision, dimension( * ) RWORK, double precision RESID)
       ZSPT01

       Purpose:

            ZSPT01 reconstructs a symmetric indefinite packed matrix A from its
            diagonal pivoting factorization A = U*D*U' or A = L*D*L' and computes
            the residual
               norm( C - A ) / ( N * norm(A) * EPS ),
            where C is the reconstructed matrix and EPS is the machine epsilon.

       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.

           A

                     A is COMPLEX*16 array, dimension (N*(N+1)/2)
                     The original symmetric matrix A, stored as a packed
                     triangular matrix.

           AFAC

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

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     The pivot indices from ZSPTRF.

           C

                     C is COMPLEX*16 array, dimension (LDC,N)

           LDC

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
                     If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zspt02 (character UPLO, integer N, integer NRHS, complex*16, dimension( * ) A,
       complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer
       LDB, double precision, dimension( * ) RWORK, double precision RESID)
       ZSPT02

       Purpose:

            ZSPT02 computes the residual in the solution of a complex symmetric
            system of linear equations  A*x = b  when packed storage is used for
            the coefficient matrix.  The ratio computed is

               RESID = norm( B - A*X ) / ( norm(A) * norm(X) * EPS).

            where EPS is the machine precision.

       Parameters:
           UPLO

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

           N

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

           NRHS

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

           A

                     A is COMPLEX*16 array, dimension (N*(N+1)/2)
                     The original complex symmetric matrix A, stored as a packed
                     triangular matrix.

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the right hand side vectors for the system of
                     linear equations.
                     On exit, B is overwritten with the difference B - A*X.

           LDB

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zspt03 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16,
       dimension( * ) AINV, complex*16, dimension( ldw, * ) WORK, integer LDW, double precision,
       dimension( * ) RWORK, double precision RCOND, double precision RESID)
       ZSPT03

       Purpose:

            ZSPT03 computes the residual for a complex symmetric packed matrix
            times its inverse:
               norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ),
            where EPS is the machine epsilon.

       Parameters:
           UPLO

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

           N

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

           A

                     A is COMPLEX*16 array, dimension (N*(N+1)/2)
                     The original complex symmetric matrix A, stored as a packed
                     triangular matrix.

           AINV

                     AINV is COMPLEX*16 array, dimension (N*(N+1)/2)
                     The (symmetric) inverse of the matrix A, stored as a packed
                     triangular matrix.

           WORK

                     WORK is COMPLEX*16 array, dimension (LDW,N)

           LDW

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RCOND

                     RCOND is DOUBLE PRECISION
                     The reciprocal of the condition number of A, computed as
                     ( 1/norm(A) ) / norm(AINV).

           RESID

                     RESID is DOUBLE PRECISION
                     norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zsyt01 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA,
       complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * ) IPIV,
       complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) RWORK,
       double precision RESID)
       ZSYT01

       Purpose:

            ZSYT01 reconstructs a complex symmetric indefinite matrix A from its
            block L*D*L' or U*D*U' factorization and computes the residual
               norm( C - A ) / ( N * norm(A) * EPS ),
            where C is the reconstructed matrix, EPS is the machine epsilon,
            L' is the transpose of L, and U' is the transpose of U.

       Parameters:
           UPLO

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

           N

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

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original complex symmetric matrix A.

           LDA

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

           AFAC

                     AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
                     The factored form of the matrix A.  AFAC contains the block
                     diagonal matrix D and the multipliers used to obtain the
                     factor L or U from the block L*D*L' or U*D*U' factorization
                     as computed by ZSYTRF.

           LDAFAC

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

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     The pivot indices from ZSYTRF.

           C

                     C is COMPLEX*16 array, dimension (LDC,N)

           LDC

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
                     If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zsyt01_rook (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer
       LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * )
       IPIV, complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * )
       RWORK, double precision RESID)
       ZSYT01_ROOK

       Purpose:

            ZSYT01_ROOK reconstructs a complex symmetric indefinite matrix A from its
            block L*D*L' or U*D*U' factorization and computes the residual
               norm( C - A ) / ( N * norm(A) * EPS ),
            where C is the reconstructed matrix, EPS is the machine epsilon,
            L' is the transpose of L, and U' is the transpose of U.

       Parameters:
           UPLO

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

           N

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

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original complex symmetric matrix A.

           LDA

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

           AFAC

                     AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
                     The factored form of the matrix A.  AFAC contains the block
                     diagonal matrix D and the multipliers used to obtain the
                     factor L or U from the block L*D*L' or U*D*U' factorization
                     as computed by ZSYTRF_ROOK.

           LDAFAC

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

           IPIV

                     IPIV is INTEGER array, dimension (N)
                     The pivot indices from ZSYTRF_ROOK.

           C

                     C is COMPLEX*16 array, dimension (LDC,N)

           LDC

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
                     If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2013

   subroutine zsyt02 (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, *
       ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)
       ZSYT02

       Purpose:

            ZSYT02 computes the residual for a solution to a complex symmetric
            system of linear equations  A*x = b:

               RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),

            where EPS is the machine epsilon.

       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 number of rows and columns of the matrix A.  N >= 0.

           NRHS

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

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original complex symmetric matrix A.

           LDA

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the right hand side vectors for the system of
                     linear equations.
                     On exit, B is overwritten with the difference B - A*X.

           LDB

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zsyt03 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA,
       complex*16, dimension( ldainv, * ) AINV, integer LDAINV, complex*16, dimension( ldwork, *
       ) WORK, integer LDWORK, double precision, dimension( * ) RWORK, double precision RCOND,
       double precision RESID)
       ZSYT03

       Purpose:

            ZSYT03 computes the residual for a complex symmetric matrix times
            its inverse:
               norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS )
            where EPS is the machine epsilon.

       Parameters:
           UPLO

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

           N

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

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original complex symmetric matrix A.

           LDA

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

           AINV

                     AINV is COMPLEX*16 array, dimension (LDAINV,N)
                     On entry, the inverse of the matrix A, stored as a symmetric
                     matrix in the same format as A.
                     In this version, AINV is expanded into a full matrix and
                     multiplied by A, so the opposing triangle of AINV will be
                     changed; i.e., if the upper triangular part of AINV is
                     stored, the lower triangular part will be used as work space.

           LDAINV

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

           WORK

                     WORK is COMPLEX*16 array, dimension (LDWORK,N)

           LDWORK

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RCOND

                     RCOND is DOUBLE PRECISION
                     The reciprocal of the condition number of A, computed as
                     RCOND = 1/ (norm(A) * norm(AINV)).

           RESID

                     RESID is DOUBLE PRECISION
                     norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztbt02 (character UPLO, character TRANS, character DIAG, integer N, integer KD,
       integer NRHS, complex*16, dimension( ldab, * ) AB, integer LDAB, complex*16, dimension(
       ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16,
       dimension( * ) WORK, double precision, dimension( * ) RWORK, double precision RESID)
       ZTBT02

       Purpose:

            ZTBT02 computes the residual for the computed solution to a
            triangular system of linear equations  A*x = b,  A**T *x = b,  or
            A**H *x = b  when A is a triangular band matrix.  Here A**T denotes
            the transpose of A, A**H denotes the conjugate transpose of A, and
            x and b are N by NRHS matrices.  The test ratio is the maximum over
            the number of right hand sides of
               norm(b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
            where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.

       Parameters:
           UPLO

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

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the operation applied to A.
                     = 'N':  A *x = b     (No transpose)
                     = 'T':  A**T *x = b  (Transpose)
                     = 'C':  A**H *x = b  (Conjugate transpose)

           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.

           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 X and B.  NRHS >= 0.

           AB

                     AB is COMPLEX*16 array, dimension (LDA,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).

           LDAB

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           WORK

                     WORK is COMPLEX*16 array, dimension (N)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(op(A)*x - b) / ( norm(op(A)) * norm(x) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztbt03 (character UPLO, character TRANS, character DIAG, integer N, integer KD,
       integer NRHS, complex*16, dimension( ldab, * ) AB, integer LDAB, double precision SCALE,
       double precision, dimension( * ) CNORM, double precision TSCAL, complex*16, dimension(
       ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16,
       dimension( * ) WORK, double precision RESID)
       ZTBT03

       Purpose:

            ZTBT03 computes the residual for the solution to a scaled triangular
            system of equations  A*x = s*b,  A**T *x = s*b,  or  A**H *x = s*b
            when A is a triangular band matrix.  Here A**T  denotes the transpose
            of A, A**H denotes the conjugate transpose of A, s is a scalar, and
            x and b are N by NRHS matrices.  The test ratio is the maximum over
            the number of right hand sides of
               norm(s*b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
            where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.

       Parameters:
           UPLO

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

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the operation applied to A.
                     = 'N':  A *x = s*b     (No transpose)
                     = 'T':  A**T *x = s*b  (Transpose)
                     = 'C':  A**H *x = s*b  (Conjugate transpose)

           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.

           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 X and B.  NRHS >= 0.

           AB

                     AB is COMPLEX*16 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).

           LDAB

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

           SCALE

                     SCALE is DOUBLE PRECISION
                     The scaling factor s used in solving the triangular system.

           CNORM

                     CNORM is DOUBLE PRECISION array, dimension (N)
                     The 1-norms of the columns of A, not counting the diagonal.

           TSCAL

                     TSCAL is DOUBLE PRECISION
                     The scaling factor used in computing the 1-norms in CNORM.
                     CNORM actually contains the column norms of TSCAL*A.

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           WORK

                     WORK is COMPLEX*16 array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(op(A)*x - s*b) / ( norm(op(A)) * norm(x) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztbt05 (character UPLO, character TRANS, character DIAG, integer N, integer KD,
       integer NRHS, complex*16, dimension( ldab, * ) AB, integer LDAB, complex*16, dimension(
       ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
       dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double
       precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)
       ZTBT05

       Purpose:

            ZTBT05 tests the error bounds from iterative refinement for the
            computed solution to a system of equations A*X = B, where A is a
            triangular band matrix.

            RESLTS(1) = test of the error bound
                      = norm(X - XACT) / ( norm(X) * FERR )

            A large value is returned if this ratio is not less than one.

            RESLTS(2) = residual from the iterative refinement routine
                      = the maximum of BERR / ( NZ*EPS + (*) ), where
                        (*) = NZ*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
                        and NZ = max. number of nonzeros in any row of A, plus 1

       Parameters:
           UPLO

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

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations.
                     = 'N':  A * X = B  (No transpose)
                     = 'T':  A'* X = B  (Transpose)
                     = 'C':  A'* X = B  (Conjugate transpose = Transpose)

           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 number of rows of the matrices X, B, and XACT, and 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.

           NRHS

                     NRHS is INTEGER
                     The number of columns of the matrices X, B, and XACT.
                     NRHS >= 0.

           AB

                     AB is COMPLEX*16 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*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors.  Each vector is stored as a
                     column of the matrix X.

           LDX

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

           XACT

                     XACT is COMPLEX*16 array, dimension (LDX,NRHS)
                     The exact solution vectors.  Each vector is stored as a
                     column of the matrix XACT.

           LDXACT

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

           FERR

                     FERR is DOUBLE PRECISION array, dimension (NRHS)
                     The estimated forward error bounds for each solution vector
                     X.  If XTRUE is the true solution, FERR bounds the magnitude
                     of the largest entry in (X - XTRUE) divided by the magnitude
                     of the largest entry in X.

           BERR

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

           RESLTS

                     RESLTS is DOUBLE PRECISION array, dimension (2)
                     The maximum over the NRHS solution vectors of the ratios:
                     RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
                     RESLTS(2) = BERR / ( NZ*EPS + (*) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztbt06 (double precision RCOND, double precision RCONDC, character UPLO, character
       DIAG, integer N, integer KD, complex*16, dimension( ldab, * ) AB, integer LDAB, double
       precision, dimension( * ) RWORK, double precision RAT)
       ZTBT06

       Purpose:

            ZTBT06 computes a test ratio comparing RCOND (the reciprocal
            condition number of a triangular matrix A) and RCONDC, the estimate
            computed by ZTBCON.  Information about the triangular matrix A is
            used if one estimate is zero and the other is non-zero to decide if
            underflow in the estimate is justified.

       Parameters:
           RCOND

                     RCOND is DOUBLE PRECISION
                     The estimate of the reciprocal condition number obtained by
                     forming the explicit inverse of the matrix A and computing
                     RCOND = 1/( norm(A) * norm(inv(A)) ).

           RCONDC

                     RCONDC is DOUBLE PRECISION
                     The estimate of the reciprocal condition number computed by
                     ZTBCON.

           UPLO

                     UPLO is CHARACTER
                     Specifies whether the matrix A is upper or lower triangular.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           DIAG

                     DIAG is CHARACTER
                     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.

           KD

                     KD is INTEGER
                     The number of superdiagonals or subdiagonals of the
                     triangular band matrix A.  KD >= 0.

           AB

                     AB is COMPLEX*16 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).

           LDAB

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

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RAT

                     RAT is DOUBLE PRECISION
                     The test ratio.  If both RCOND and RCONDC are nonzero,
                        RAT = MAX( RCOND, RCONDC )/MIN( RCOND, RCONDC ) - 1.
                     If RAT = 0, the two estimates are exactly the same.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztpt01 (character UPLO, character DIAG, integer N, complex*16, dimension( * ) AP,
       complex*16, dimension( * ) AINVP, double precision RCOND, double precision, dimension( * )
       RWORK, double precision RESID)
       ZTPT01

       Purpose:

            ZTPT01 computes the residual for a triangular matrix A times its
            inverse when A is stored in packed format:
               RESID = norm(A*AINV - I) / ( N * norm(A) * norm(AINV) * EPS ),
            where EPS is the machine epsilon.

       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.

           AP

                     AP is COMPLEX*16 array, dimension (N*(N+1)/2)
                     The original 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((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L',
                        AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.

           AINVP

                     AINVP is COMPLEX*16 array, dimension (N*(N+1)/2)
                     On entry, the (triangular) inverse of the matrix A, packed
                     columnwise in a linear array as in AP.
                     On exit, the contents of AINVP are destroyed.

           RCOND

                     RCOND is DOUBLE PRECISION
                     The reciprocal condition number of A, computed as
                     1/(norm(A) * norm(AINV)).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     norm(A*AINV - I) / ( N * norm(A) * norm(AINV) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztpt02 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex*16, dimension( * ) AP, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
       dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, double precision RESID)
       ZTPT02

       Purpose:

            ZTPT02 computes the residual for the computed solution to a
            triangular system of linear equations  A*x = b,  A**T *x = b,  or
            A**H *x = b, when the triangular matrix A is stored in packed format.
            Here A**T denotes the transpose of A, A**H denotes the conjugate
            transpose of A, and x and b are N by NRHS matrices.  The test ratio
            is the maximum over the number of right hand sides of
            the maximum over the number of right hand sides of
               norm(b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
            where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.

       Parameters:
           UPLO

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

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the operation applied to A.
                     = 'N':  A *x = b     (No transpose)
                     = 'T':  A**T *x = b  (Transpose)
                     = 'C':  A**H *x = b  (Conjugate transpose)

           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.

           NRHS

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

           AP

                     AP is COMPLEX*16 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((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L',
                        AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           WORK

                     WORK is COMPLEX*16 array, dimension (N)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(op(A)*x - b) / ( norm(op(A)) * norm(x) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztpt03 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex*16, dimension( * ) AP, double precision SCALE, double precision, dimension( * )
       CNORM, double precision TSCAL, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
       dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK, double precision
       RESID)
       ZTPT03

       Purpose:

            ZTPT03 computes the residual for the solution to a scaled triangular
            system of equations A*x = s*b,  A**T *x = s*b,  or  A**H *x = s*b,
            when the triangular matrix A is stored in packed format.  Here A**T
            denotes the transpose of A, A**H denotes the conjugate transpose of
            A, s is a scalar, and x and b are N by NRHS matrices.  The test ratio
            is the maximum over the number of right hand sides of
               norm(s*b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
            where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.

       Parameters:
           UPLO

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

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the operation applied to A.
                     = 'N':  A *x = s*b     (No transpose)
                     = 'T':  A**T *x = s*b  (Transpose)
                     = 'C':  A**H *x = s*b  (Conjugate transpose)

           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.

           NRHS

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

           AP

                     AP is COMPLEX*16 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((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L',
                        AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.

           SCALE

                     SCALE is DOUBLE PRECISION
                     The scaling factor s used in solving the triangular system.

           CNORM

                     CNORM is DOUBLE PRECISION array, dimension (N)
                     The 1-norms of the columns of A, not counting the diagonal.

           TSCAL

                     TSCAL is DOUBLE PRECISION
                     The scaling factor used in computing the 1-norms in CNORM.
                     CNORM actually contains the column norms of TSCAL*A.

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           WORK

                     WORK is COMPLEX*16 array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(op(A)*x - s*b) / ( norm(op(A)) * norm(x) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztpt05 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex*16, dimension( * ) AP, complex*16, dimension( ldb, * ) B, integer LDB, complex*16,
       dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer
       LDXACT, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR,
       double precision, dimension( * ) RESLTS)
       ZTPT05

       Purpose:

            ZTPT05 tests the error bounds from iterative refinement for the
            computed solution to a system of equations A*X = B, where A is a
            triangular matrix in packed storage format.

            RESLTS(1) = test of the error bound
                      = norm(X - XACT) / ( norm(X) * FERR )

            A large value is returned if this ratio is not less than one.

            RESLTS(2) = residual from the iterative refinement routine
                      = the maximum of BERR / ( (n+1)*EPS + (*) ), where
                        (*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )

       Parameters:
           UPLO

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

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations.
                     = 'N':  A * X = B  (No transpose)
                     = 'T':  A'* X = B  (Transpose)
                     = 'C':  A'* X = B  (Conjugate transpose = Transpose)

           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 number of rows of the matrices X, B, and XACT, and the
                     order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of columns of the matrices X, B, and XACT.
                     NRHS >= 0.

           AP

                     AP is COMPLEX*16 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*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors.  Each vector is stored as a
                     column of the matrix X.

           LDX

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

           XACT

                     XACT is COMPLEX*16 array, dimension (LDX,NRHS)
                     The exact solution vectors.  Each vector is stored as a
                     column of the matrix XACT.

           LDXACT

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

           FERR

                     FERR is DOUBLE PRECISION array, dimension (NRHS)
                     The estimated forward error bounds for each solution vector
                     X.  If XTRUE is the true solution, FERR bounds the magnitude
                     of the largest entry in (X - XTRUE) divided by the magnitude
                     of the largest entry in X.

           BERR

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

           RESLTS

                     RESLTS is DOUBLE PRECISION array, dimension (2)
                     The maximum over the NRHS solution vectors of the ratios:
                     RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
                     RESLTS(2) = BERR / ( (n+1)*EPS + (*) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztpt06 (double precision RCOND, double precision RCONDC, character UPLO, character
       DIAG, integer N, complex*16, dimension( * ) AP, double precision, dimension( * ) RWORK,
       double precision RAT)
       ZTPT06

       Purpose:

            ZTPT06 computes a test ratio comparing RCOND (the reciprocal
            condition number of the triangular matrix A) and RCONDC, the estimate
            computed by ZTPCON.  Information about the triangular matrix is used
            if one estimate is zero and the other is non-zero to decide if
            underflow in the estimate is justified.

       Parameters:
           RCOND

                     RCOND is DOUBLE PRECISION
                     The estimate of the reciprocal condition number obtained by
                     forming the explicit inverse of the matrix A and computing
                     RCOND = 1/( norm(A) * norm(inv(A)) ).

           RCONDC

                     RCONDC is DOUBLE PRECISION
                     The estimate of the reciprocal condition number computed by
                     ZTPCON.

           UPLO

                     UPLO is CHARACTER
                     Specifies whether the matrix A is upper or lower triangular.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           DIAG

                     DIAG is CHARACTER
                     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.

           AP

                     AP is COMPLEX*16 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((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
                     if UPLO = 'L',
                        AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RAT

                     RAT is DOUBLE PRECISION
                     The test ratio.  If both RCOND and RCONDC are nonzero,
                        RAT = MAX( RCOND, RCONDC )/MIN( RCOND, RCONDC ) - 1.
                     If RAT = 0, the two estimates are exactly the same.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztrt01 (character UPLO, character DIAG, integer N, complex*16, dimension( lda, * )
       A, integer LDA, complex*16, dimension( ldainv, * ) AINV, integer LDAINV, double precision
       RCOND, double precision, dimension( * ) RWORK, double precision RESID)
       ZTRT01

       Purpose:

            ZTRT01 computes the residual for a triangular matrix A times its
            inverse:
               RESID = norm( A*AINV - I ) / ( N * norm(A) * norm(AINV) * EPS ),
            where EPS is the machine epsilon.

       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*16 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).

           AINV

                     AINV is COMPLEX*16 array, dimension (LDAINV,N)
                     On entry, the (triangular) inverse of the matrix A, in the
                     same storage format as A.
                     On exit, the contents of AINV are destroyed.

           LDAINV

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

           RCOND

                     RCOND is DOUBLE PRECISION
                     The reciprocal condition number of A, computed as
                     1/(norm(A) * norm(AINV)).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     norm(A*AINV - I) / ( N * norm(A) * norm(AINV) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztrt02 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer
       LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK,
       double precision, dimension( * ) RWORK, double precision RESID)
       ZTRT02

       Purpose:

            ZTRT02 computes the residual for the computed solution to a
            triangular system of linear equations  A*x = b,  A**T *x = b,
            or A**H *x = b.  Here A is a triangular matrix, A**T is the transpose
            of A, A**H is the conjugate transpose of A, and x and b are N by NRHS
            matrices.  The test ratio is the maximum over the number of right
            hand sides of
               norm(b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
            where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.

       Parameters:
           UPLO

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

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the operation applied to A.
                     = 'N':  A *x = b     (No transpose)
                     = 'T':  A**T *x = b  (Transpose)
                     = 'C':  A**H *x = b  (Conjugate transpose)

           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.

           NRHS

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

           A

                     A is COMPLEX*16 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).

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           WORK

                     WORK is COMPLEX*16 array, dimension (N)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(op(A)*x - b) / ( norm(op(A)) * norm(x) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztrt03 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex*16, dimension( lda, * ) A, integer LDA, double precision SCALE, double precision,
       dimension( * ) CNORM, double precision TSCAL, complex*16, dimension( ldx, * ) X, integer
       LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK,
       double precision RESID)
       ZTRT03

       Purpose:

            ZTRT03 computes the residual for the solution to a scaled triangular
            system of equations A*x = s*b,  A**T *x = s*b,  or  A**H *x = s*b.
            Here A is a triangular matrix, A**T denotes the transpose of A, A**H
            denotes the conjugate transpose of A, s is a scalar, and x and b are
            N by NRHS matrices.  The test ratio is the maximum over the number of
            right hand sides of
               norm(s*b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
            where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.

       Parameters:
           UPLO

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

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the operation applied to A.
                     = 'N':  A *x = s*b     (No transpose)
                     = 'T':  A**T *x = s*b  (Transpose)
                     = 'C':  A**H *x = s*b  (Conjugate transpose)

           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.

           NRHS

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

           A

                     A is COMPLEX*16 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).

           SCALE

                     SCALE is DOUBLE PRECISION
                     The scaling factor s used in solving the triangular system.

           CNORM

                     CNORM is DOUBLE PRECISION array, dimension (N)
                     The 1-norms of the columns of A, not counting the diagonal.

           TSCAL

                     TSCAL is DOUBLE PRECISION
                     The scaling factor used in computing the 1-norms in CNORM.
                     CNORM actually contains the column norms of TSCAL*A.

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

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

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           WORK

                     WORK is COMPLEX*16 array, dimension (N)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(op(A)*x - s*b) / ( norm(op(A)) * norm(x) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztrt05 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
       complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B, integer
       LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * )
       XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision, dimension(
       * ) BERR, double precision, dimension( * ) RESLTS)
       ZTRT05

       Purpose:

            ZTRT05 tests the error bounds from iterative refinement for the
            computed solution to a system of equations A*X = B, where A is a
            triangular n by n matrix.

            RESLTS(1) = test of the error bound
                      = norm(X - XACT) / ( norm(X) * FERR )

            A large value is returned if this ratio is not less than one.

            RESLTS(2) = residual from the iterative refinement routine
                      = the maximum of BERR / ( (n+1)*EPS + (*) ), where
                        (*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )

       Parameters:
           UPLO

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

           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations.
                     = 'N':  A * X = B  (No transpose)
                     = 'T':  A'* X = B  (Transpose)
                     = 'C':  A'* X = B  (Conjugate transpose = Transpose)

           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 number of rows of the matrices X, B, and XACT, and the
                     order of the matrix A.  N >= 0.

           NRHS

                     NRHS is INTEGER
                     The number of columns of the matrices X, B, and XACT.
                     NRHS >= 0.

           A

                     A is COMPLEX*16 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*16 array, dimension (LDB,NRHS)
                     The right hand side vectors for the system of linear
                     equations.

           LDB

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors.  Each vector is stored as a
                     column of the matrix X.

           LDX

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

           XACT

                     XACT is COMPLEX*16 array, dimension (LDX,NRHS)
                     The exact solution vectors.  Each vector is stored as a
                     column of the matrix XACT.

           LDXACT

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

           FERR

                     FERR is DOUBLE PRECISION array, dimension (NRHS)
                     The estimated forward error bounds for each solution vector
                     X.  If XTRUE is the true solution, FERR bounds the magnitude
                     of the largest entry in (X - XTRUE) divided by the magnitude
                     of the largest entry in X.

           BERR

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

           RESLTS

                     RESLTS is DOUBLE PRECISION array, dimension (2)
                     The maximum over the NRHS solution vectors of the ratios:
                     RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
                     RESLTS(2) = BERR / ( (n+1)*EPS + (*) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine ztrt06 (double precision RCOND, double precision RCONDC, character UPLO, character
       DIAG, integer N, complex*16, dimension( lda, * ) A, integer LDA, double precision,
       dimension( * ) RWORK, double precision RAT)
       ZTRT06

       Purpose:

            ZTRT06 computes a test ratio comparing RCOND (the reciprocal
            condition number of a triangular matrix A) and RCONDC, the estimate
            computed by ZTRCON.  Information about the triangular matrix A is
            used if one estimate is zero and the other is non-zero to decide if
            underflow in the estimate is justified.

       Parameters:
           RCOND

                     RCOND is DOUBLE PRECISION
                     The estimate of the reciprocal condition number obtained by
                     forming the explicit inverse of the matrix A and computing
                     RCOND = 1/( norm(A) * norm(inv(A)) ).

           RCONDC

                     RCONDC is DOUBLE PRECISION
                     The estimate of the reciprocal condition number computed by
                     ZTRCON.

           UPLO

                     UPLO is CHARACTER
                     Specifies whether the matrix A is upper or lower triangular.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           DIAG

                     DIAG is CHARACTER
                     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*16 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).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RAT

                     RAT is DOUBLE PRECISION
                     The test ratio.  If both RCOND and RCONDC are nonzero,
                        RAT = MAX( RCOND, RCONDC )/MIN( RCOND, RCONDC ) - 1.
                     If RAT = 0, the two estimates are exactly the same.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

Author

       Generated automatically by Doxygen for LAPACK from the source code.