LAPACK
3.4.2
LAPACK: Linear Algebra PACKage

Functions/Subroutines  
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  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  zchkqp (DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR, A, COPYA, S, TAU, WORK, RWORK, IWORK, NOUT) 
ZCHKQP  
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  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  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  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  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  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  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  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  
DOUBLE PRECISION function  ztzt01 (M, N, A, AF, LDA, TAU, WORK, LWORK) 
ZTZT01  
DOUBLE PRECISION function  ztzt02 (M, N, AF, LDA, TAU, WORK, LWORK) 
ZTZT02 
This is the group of complex16 LAPACK TESTING LIN routines.
program zchkaa  (  ) 
ZCHKAA
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 listdirected 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 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
Definition at line 109 of file zchkaa.f.
program zchkab  (  ) 
ZCHKAB
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 listdirected 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
Definition at line 74 of file zchkab.f.
subroutine zchkeq  (  double precision  THRESH, 
integer  NOUT  
) 
ZCHKEQ
ZCHKEQ tests ZGEEQU, ZGBEQU, ZPOEQU, ZPPEQU and ZPBEQU
[in]  THRESH  THRESH is DOUBLE PRECISION Threshold for testing routines. Should be between 2 and 10. 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 55 of file zchkeq.f.
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
ZCHKGB tests ZGBTRF, TRS, RFS, and CON
[in]  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. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is COMPLEX*16 array, dimension (LA) 
[in]  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. 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (LAFAC) 
[in]  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. 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX,NMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 190 of file zchkgb.f.
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
ZCHKGE tests ZGETRF, TRI, TRS, RFS, and CON.
[in]  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. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(2*NMAX,2*NSMAX+NWORK)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 185 of file zchkge.f.
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
ZCHKGT tests ZGTTRF, TRS, RFS, and CON
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*4) 
[out]  AF  AF is COMPLEX*16 array, dimension (NMAX*4) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX)+2*NSMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 147 of file zchkgt.f.
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
ZCHKHE tests ZHETRF, TRI2, TRS, TRS2, RFS, and CON.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 172 of file zchkhe.f.
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
ZCHKHP tests ZHPTRF, TRI, TRS, RFS, and CON
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(2,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NSMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 163 of file zchkhp.f.
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
ZCHKLQ tests ZGELQF, ZUNGLQ and CUNMLQ.
[in]  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. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  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). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AF  AF is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AL  AL is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AC  AC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is COMPLEX*16 array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 195 of file zchklq.f.
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
ZCHKPB tests ZPBTRF, TRS, RFS, and CON.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX) 
[out]  B  B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 167 of file zchkpb.f.
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
ZCHKPO tests ZPOTRF, TRI, TRS, RFS, and CON
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NSMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 167 of file zchkpo.f.
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
ZCHKPP tests ZPPTRF, TRI, TRS, RFS, and CON
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 158 of file zchkpp.f.
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
ZCHKPS tests ZPSTRF.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the block size NB. 
[in]  NRANK  NRANK is INTEGER The number of values of RANK contained in the vector RANKVAL. 
[in]  RANKVAL  RANKVAL is INTEGER array, dimension (NBVAL) The values of the block size NB. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  PERM  PERM is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  PIV  PIV is INTEGER array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*3) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 153 of file zchkps.f.
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
ZCHKPT tests ZPTTRF, TRS, RFS, and CON
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*2) 
[out]  D  D is DOUBLE PRECISION array, dimension (NMAX*2) 
[out]  E  E is COMPLEX*16 array, dimension (NMAX*2) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 147 of file zchkpt.f.
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
ZCHKQ3 tests ZGEQP3.
[in]  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. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  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). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  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. 
[out]  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. 
[out]  COPYA  COPYA is COMPLEX*16 array, dimension (MMAX*NMAX) 
[out]  S  S is DOUBLE PRECISION array, dimension (min(MMAX,NMAX)) 
[out]  TAU  TAU is COMPLEX*16 array, dimension (MMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (max(M*max(M,N) + 4*min(M,N) + max(M,N))) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (4*NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 157 of file zchkq3.f.
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
ZCHKQL tests ZGEQLF, ZUNGQL and CUNMQL.
[in]  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. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  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). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AF  AF is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AL  AL is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AC  AC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is COMPLEX*16 array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 195 of file zchkql.f.
subroutine zchkqp  (  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, dimension( * )  IWORK,  
integer  NOUT  
) 
ZCHKQP
ZCHKQP tests ZGEQPF.
[in]  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. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  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. 
[out]  COPYA  COPYA is COMPLEX*16 array, dimension (MMAX*NMAX) 
[out]  S  S is DOUBLE PRECISION array, dimension (min(MMAX,NMAX)) 
[out]  TAU  TAU is COMPLEX*16 array, dimension (MMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (max(M*max(M,N) + 4*min(M,N) + max(M,N))) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (4*NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 143 of file zchkqp.f.
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
ZCHKQR tests ZGEQRF, ZUNGQR and CUNMQR.
[in]  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. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  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). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AF  AF is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AR  AR is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AC  AC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is COMPLEX*16 array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 200 of file zchkqr.f.
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
ZCHKQRT tests ZGEQRT and ZGEMQRT.
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 101 of file zchkqrt.f.
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
ZCHKQRTP tests ZTPQRT and ZTPMQRT.
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 102 of file zchkqrtp.f.
program zchkrfp  (  ) 
ZCHKRFP
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
Definition at line 60 of file zchkrfp.f.
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
ZCHKRQ tests ZGERQF, ZUNGRQ and CUNMRQ.
[in]  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. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  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). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AF  AF is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AR  AR is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AC  AC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is COMPLEX*16 array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 200 of file zchkrq.f.
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
ZCHKSP tests ZSPTRF, TRI, TRS, RFS, and CON
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(2,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NSMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 163 of file zchksp.f.
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
ZCHKSY tests ZSYTRF, TRI2, TRS, TRS2, RFS, and CON.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(2,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NSMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 172 of file zchksy.f.
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
ZCHKTB tests ZTBTRS, RFS, and CON, and ZLATBS.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The leading dimension of the work arrays. NMAX >= the maximum value of N in NVAL. 
[out]  AB  AB is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 149 of file zchktb.f.
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
ZCHKTP tests ZTPTRI, TRS, RFS, and CON, and ZLATPS
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The leading dimension of the work arrays. NMAX >= the maximumm value of N in NVAL. 
[out]  AP  AP is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINVP  AINVP is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 150 of file zchktp.f.
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
ZCHKTR tests ZTRTRI, TRS, RFS, and CON, and ZLATRS
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The leading dimension of the work arrays. NMAX >= the maximum value of N in NVAL. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 162 of file zchktr.f.
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
ZCHKTZ tests ZTZRQF and ZTZRZF.
[in]  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. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  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. 
[out]  COPYA  COPYA is COMPLEX*16 array, dimension (MMAX*NMAX) 
[out]  S  S is DOUBLE PRECISION array, dimension (min(MMAX,NMAX)) 
[out]  TAU  TAU is COMPLEX*16 array, dimension (MMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (MMAX*NMAX + 4*NMAX + MMAX) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 137 of file zchktz.f.
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
ZDRVAB tests ZCGESV
[in]  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. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX*2)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension NMAX 
[out]  SWORK  SWORK is COMPLEX array, dimension (NMAX*(NSMAX+NMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension NMAX 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 151 of file zdrvab.f.
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
ZDRVAC tests ZCPOSV.
[in]  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. 
[in]  NM  NM is INTEGER The number of values of N contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(2*NMAX,2*NSMAX+NWORK)) 
[out]  SWORK  SWORK is COMPLEX array, dimension (NMAX*(NSMAX+NMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 144 of file zdrvac.f.
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
ZDRVGB tests the driver routines ZGBSV and SVX.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is COMPLEX*16 array, dimension (LA) 
[in]  LA  LA is INTEGER The length of the array A. LA >= (2*NMAX1)*NMAX where NMAX is the largest entry in NVAL. 
[out]  AFB  AFB is COMPLEX*16 array, dimension (LAFB) 
[in]  LAFB  LAFB is INTEGER The length of the array AFB. LAFB >= (3*NMAX2)*NMAX where NMAX is the largest entry in NVAL. 
[out]  ASAV  ASAV is COMPLEX*16 array, dimension (LA) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (2*NMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS,NMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NRHS)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
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.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is COMPLEX*16 array, dimension (LA) 
[in]  LA  LA is INTEGER The length of the array A. LA >= (2*NMAX1)*NMAX where NMAX is the largest entry in NVAL. 
[out]  AFB  AFB is COMPLEX*16 array, dimension (LAFB) 
[in]  LAFB  LAFB is INTEGER The length of the array AFB. LAFB >= (3*NMAX2)*NMAX where NMAX is the largest entry in NVAL. 
[out]  ASAV  ASAV is COMPLEX*16 array, dimension (LA) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (2*NMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS,NMAX)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NRHS)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 171 of file zdrvgb.f.
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
ZDRVGE tests the driver routines ZGESV and SVX.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (2*NMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (2*NRHS+NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
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.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (2*NMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (2*NRHS+NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 163 of file zdrvge.f.
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
ZDRVGT tests ZGTSV and SVX.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, NRHS >= 0. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*4) 
[out]  AF  AF is COMPLEX*16 array, dimension (NMAX*4) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 139 of file zdrvgt.f.
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
ZDRVHE tests the driver routines ZHESV and SVX.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
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.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (2*NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 153 of file zdrvhe.f.
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
ZDRVHP tests the driver routines ZHPSV and SVX.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 156 of file zdrvhp.f.
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
ZDRVLS tests the least squares driver routines ZGELS, CGELSX, CGELSS, ZGELSY and CGELSD.
[in]  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 rankdeficient. j=5: The same of 4, but A is scaled up. j=6: The same of 5, but A is scaled down. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  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). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  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. 
[out]  COPYA  COPYA is COMPLEX*16 array, dimension (MMAX*NMAX) 
[out]  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. 
[out]  COPYB  COPYB is COMPLEX*16 array, dimension (MMAX*NSMAX) 
[out]  C  C is COMPLEX*16 array, dimension (MMAX*NSMAX) 
[out]  S  S is DOUBLE PRECISION array, dimension (min(MMAX,NMAX)) 
[out]  COPYS  COPYS is DOUBLE PRECISION array, dimension (min(MMAX,NMAX)) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (MMAX*NMAX + 4*NMAX + MMAX). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (5*NMAX1) 
[out]  IWORK  IWORK is INTEGER array, dimension (15*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 208 of file zdrvls.f.
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
ZDRVPB tests the driver routines ZPBSV and SVX.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 158 of file zdrvpb.f.
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
ZDRVPO tests the driver routines ZPOSV and SVX.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
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.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 158 of file zdrvpo.f.
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
ZDRVPP tests the driver routines ZPPSV and SVX.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  ASAV  ASAV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  S  S is DOUBLE PRECISION array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 158 of file zdrvpp.f.
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
ZDRVPT tests ZPTSV and SVX.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*2) 
[out]  D  D is DOUBLE PRECISION array, dimension (NMAX*2) 
[out]  E  E is COMPLEX*16 array, dimension (NMAX*2) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 140 of file zdrvpt.f.
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
ZDRVRF1 tests the LAPACK RFP routines: ZLANHF.F
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  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. 
[out]  A  A is COMPLEX*16 array, dimension (LDA,NMAX) 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  ARF  ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2). 
[out]  WORK  WORK is DOUBLE PRECISION array, dimension ( NMAX ) 
Definition at line 96 of file zdrvrf1.f.
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
ZDRVRF2 tests the LAPACK RFP convertion routines.
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[out]  A  A is COMPLEX*16 array, dimension (LDA,NMAX) 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  ARF  ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2). 
[out]  AP  AP is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2). 
[out]  ASAV  ASAV is COMPLEX*16 array, dimension (LDA,NMAX) 
Definition at line 90 of file zdrvrf2.f.
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
ZDRVRF3 tests the LAPACK RFP routines: ZTFSM
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  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. 
[out]  A  A is COMPLEX*16 array, dimension (LDA,NMAX) 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  ARF  ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2). 
[out]  B1  B1 is COMPLEX*16 array, dimension (LDA,NMAX) 
[out]  B2  B2 is COMPLEX*16 array, dimension (LDA,NMAX) 
[out]  D_WORK_ZLANGE  D_WORK_ZLANGE is DOUBLE PRECISION array, dimension (NMAX) 
[out]  Z_WORK_ZGEQRF  Z_WORK_ZGEQRF is COMPLEX*16 array, dimension (NMAX) 
[out]  TAU  TAU is COMPLEX*16 array, dimension (NMAX) 
Definition at line 119 of file zdrvrf3.f.
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
ZDRVRF4 tests the LAPACK RFP routines: ZHFRK
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  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. 
[out]  C1  C1 is COMPLEX*16 array, dimension (LDC,NMAX) 
[out]  C2  C2 is COMPLEX*16 array, dimension (LDC,NMAX) 
[in]  LDC  LDC is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  CRF  CRF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2). 
[out]  A  A is COMPLEX*16 array, dimension (LDA,NMAX) 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  D_WORK_ZLANGE  D_WORK_ZLANGE is DOUBLE PRECISION array, dimension (NMAX) 
Definition at line 114 of file zdrvrf4.f.
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
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 NbyNRHS 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(XXACT) * RCOND ) / ( norm(XACT) * EPS ), where EPS is the machine precision, RCOND the condition number of A, and norm( . ) the 1norm for (1,2,3) and the infnorm for (4). Errors occur when INFO parameter is not as expected. Failures occur when a test ratios is greater than THRES.
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of righthand sides NRHS. 
[in]  NNT  NNT is INTEGER The number of values of MATRIX TYPE contained in the vector NTVAL. 
[in]  NTVAL  NTVAL is INTEGER array, dimension (NNT) The values of matrix type (between 0 and 9 for PO/PP/PF matrices). 
[in]  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. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*MAXRHS) 
[out]  BSAV  BSAV is COMPLEX*16 array, dimension (NMAX*MAXRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*MAXRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*MAXRHS) 
[out]  ARF  ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2) 
[out]  ARFINV  ARFINV is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2) 
[out]  Z_WORK_ZLATMS  Z_WORK_ZLATMS is COMPLEX*16 array, dimension ( 3*NMAX ) 
[out]  Z_WORK_ZPOT02  Z_WORK_ZPOT02 is COMPLEX*16 array, dimension ( NMAX*MAXRHS ) 
[out]  Z_WORK_ZPOT03  Z_WORK_ZPOT03 is COMPLEX*16 array, dimension ( NMAX*NMAX ) 
[out]  D_WORK_ZLATMS  D_WORK_ZLATMS is DOUBLE PRECISION array, dimension ( NMAX ) 
[out]  D_WORK_ZLANHE  D_WORK_ZLANHE is DOUBLE PRECISION array, dimension ( NMAX ) 
[out]  D_WORK_ZPOT01  D_WORK_ZPOT01 is DOUBLE PRECISION array, dimension ( NMAX ) 
[out]  D_WORK_ZPOT02  D_WORK_ZPOT02 is DOUBLE PRECISION array, dimension ( NMAX ) 
[out]  D_WORK_ZPOT03  D_WORK_ZPOT03 is DOUBLE PRECISION array, dimension ( NMAX ) 
Definition at line 240 of file zdrvrfp.f.
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
ZDRVSP tests the driver routines ZSPSV and SVX.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 156 of file zdrvsp.f.
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
ZDRVSY tests the driver routines ZSYSV and SVX.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
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.
[in]  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. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  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. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NMAX  NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays. 
[out]  A  A is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX*16 array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX*16 array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (2*NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 153 of file zdrvsy.f.
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.
Definition at line 97 of file zebchvxx.f.
subroutine zerrab  (  integer  NUNIT  ) 
subroutine zerrac  (  integer  NUNIT  ) 
subroutine zerrge  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRGE
ZERRGEX
ZERRGE tests the error exits for the COMPLEX*16 routines for general matrices.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
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.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrge.f.
subroutine zerrgt  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRGT
ZERRGT tests the error exits for the COMPLEX*16 tridiagonal routines.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrgt.f.
subroutine zerrhe  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRHE
ZERRHEX
ZERRHE tests the error exits for the COMPLEX*16 routines for Hermitian indefinite matrices.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
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.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrhe.f.
subroutine zerrlq  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRLQ
ZERRLQ tests the error exits for the COMPLEX*16 routines that use the LQ decomposition of a general matrix.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrlq.f.
subroutine zerrls  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRLS
ZERRLS tests the error exits for the COMPLEX*16 least squares driver routines (ZGELS, CGELSS, CGELSX, CGELSY, CGELSD).
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrls.f.
subroutine zerrpo  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRPO
ZERRPOX
ZERRPO tests the error exits for the COMPLEX*16 routines for Hermitian positive definite matrices.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
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.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrpo.f.
subroutine zerrps  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRPS
ZERRPS tests the error exits for the COMPLEX routines for ZPSTRF.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrps.f.
subroutine zerrql  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRQL
ZERRQL tests the error exits for the COMPLEX*16 routines that use the QL decomposition of a general matrix.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrql.f.
subroutine zerrqp  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRQP
ZERRQP tests the error exits for ZGEQPF and CGEQP3.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 55 of file zerrqp.f.
subroutine zerrqr  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRQR
ZERRQR tests the error exits for the COMPLEX*16 routines that use the QR decomposition of a general matrix.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrqr.f.
subroutine zerrqrt  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRQRT
ZERRQRT tests the error exits for the COMPLEX*16 routines that use the QRT decomposition of a general matrix.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrqrt.f.
subroutine zerrqrtp  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRQRTP
ZERRQRTP tests the error exits for the COMPLEX*16 routines that use the QRT decomposition of a triangularpentagonal matrix.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrqrtp.f.
subroutine zerrrfp  (  integer  NUNIT  ) 
ZERRRFP
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
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 53 of file zerrrfp.f.
subroutine zerrrq  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRRQ
ZERRRQ tests the error exits for the COMPLEX*16 routines that use the RQ decomposition of a general matrix.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrrq.f.
subroutine zerrsy  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRSY
ZERRSYX
ZERRSY tests the error exits for the COMPLEX*16 routines for symmetric indefinite matrices.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
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.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrsy.f.
subroutine zerrtr  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRTR
ZERRTR tests the error exits for the COMPLEX*16 triangular routines.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 55 of file zerrtr.f.
subroutine zerrtz  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRTZ
ZERRTZ tests the error exits for ZTZRQF and ZTZRZF.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 55 of file zerrtz.f.
subroutine zerrvx  (  character*3  PATH, 
integer  NUNIT  
) 
ZERRVX
ZERRVXX
ZERRVX tests the error exits for the COMPLEX*16 driver routines for solving linear systems of equations.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
ZERRVX tests the error exits for the COMPLEX*16 driver routines for solving linear systems of equations.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file zerrvx.f.
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
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.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  KL  KL is INTEGER The number of subdiagonals within the band of A. KL >= 0. 
[in]  KU  KU is INTEGER The number of superdiagonals within the band of A. KU >= 0. 
[in,out]  A  A is COMPLEX*16 array, dimension (LDA,N) The original matrix A in band storage, stored in rows 1 to KL+KU+1. 
[in]  LDA  LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,KL+KU+1). 
[in]  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. 
[in]  LDAFAC  LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,2*KL*KU+1). 
[in]  IPIV  IPIV is INTEGER array, dimension (min(M,N)) The pivot indices from ZGBTRF. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (2*KL+KU+1) 
[out]  RESID  RESID is DOUBLE PRECISION norm(L*U  A) / ( N * norm(A) * EPS ) 
Definition at line 126 of file zgbt01.f.
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
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.
[in]  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 
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  KL  KL is INTEGER The number of subdiagonals within the band of A. KL >= 0. 
[in]  KU  KU is INTEGER The number of superdiagonals within the band of A. KU >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B. NRHS >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The original matrix A in band storage, stored in rows 1 to KL+KU+1. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,KL+KU+1). 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations. 
[in]  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). 
[in,out]  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. 
[in]  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). 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 139 of file zgbt02.f.
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
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
[in]  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) 
[in]  N  N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0. 
[in]  KL  KL is INTEGER The number of subdiagonals within the band of A. KL >= 0. 
[in]  KU  KU is INTEGER The number of superdiagonals within the band of A. KU >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0. 
[in]  AB  AB is COMPLEX*16 array, dimension (LDAB,N) The original band matrix A, stored in rows 1 to KL+KU+1. The jth column of A is stored in the jth column of the array AB as follows: AB(ku+1+ij,j) = A(i,j) for max(1,jku)<=i<=min(n,j+kl). 
[in]  LDAB  LDAB is INTEGER The leading dimension of the array AB. LDAB >= KL+KU+1. 
[in]  B  B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). 
[in]  XACT  XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  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. 
[in]  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). 
[out]  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 + (*) ) 
Definition at line 176 of file zgbt05.f.
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
Compute a minimumnorm solution min  A*X  B  using the LQ factorization A = L*Q computed by ZGELQF.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= M >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B. NRHS >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) Details of the LQ factorization of the original matrix A as returned by ZGELQF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is COMPLEX*16 array, dimension (M) Details of the orthogonal matrix Q. 
[in,out]  B  B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the mbynrhs right hand side matrix B. On exit, the nbynrhs solution matrix X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= N. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  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. 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 121 of file zgelqs.f.
LOGICAL function zgennd  (  integer  M, 
integer  N,  
complex*16, dimension( lda, * )  A,  
integer  LDA  
) 
ZGENND
ZGENND tests that its argument has a real, nonnegative diagonal.
[in]  M  M is INTEGER The number of rows in A. 
[in]  N  N is INTEGER The number of columns in A. 
[in]  A  A is COMPLEX*16 array, dimension (LDA, N) The matrix. 
[in]  LDA  LDA is INTEGER Leading dimension of A. 
Definition at line 69 of file zgennd.f.
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
Solve the least squares problem min  A*X  B  using the QL factorization A = Q*L computed by ZGEQLF.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. M >= N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B. NRHS >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) Details of the QL factorization of the original matrix A as returned by ZGEQLF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is COMPLEX*16 array, dimension (N) Details of the orthogonal matrix Q. 
[in,out]  B  B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the mbynrhs right hand side matrix B. On exit, the nbynrhs solution matrix X, stored in rows mn+1:m. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= M. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  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. 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 122 of file zgeqls.f.
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
Solve the least squares problem min  A*X  B  using the QR factorization A = Q*R computed by ZGEQRF.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. M >= N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B. NRHS >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) Details of the QR factorization of the original matrix A as returned by ZGEQRF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is COMPLEX*16 array, dimension (N) Details of the orthogonal matrix Q. 
[in,out]  B  B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the mbynrhs right hand side matrix B. On exit, the nbynrhs solution matrix X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= M. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  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. 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 121 of file zgeqrs.f.
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
Compute a minimumnorm solution min  A*X  B  using the RQ factorization A = R*Q computed by ZGERQF.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= M >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B. NRHS >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) Details of the RQ factorization of the original matrix A as returned by ZGERQF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is COMPLEX*16 array, dimension (M) Details of the orthogonal matrix Q. 
[in,out]  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. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  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. 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 122 of file zgerqs.f.
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
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.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The original M x N matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M). 
[in,out]  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. 
[in]  LDAFAC  LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,M). 
[in]  IPIV  IPIV is INTEGER array, dimension (N) The pivot indices from ZGETRF. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESID  RESID is DOUBLE PRECISION norm(L*U  A) / ( N * norm(A) * EPS ) 
Definition at line 108 of file zget01.f.
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
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.
[in]  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 
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The original M x N matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M). 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations. 
[in]  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). 
[in,out]  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. 
[in]  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). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 133 of file zget02.f.
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
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.
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The original N x N matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[in]  AINV  AINV is COMPLEX*16 array, dimension (LDAINV,N) The inverse of the matrix A. 
[in]  LDAINV  LDAINV is INTEGER The leading dimension of the array AINV. LDAINV >= max(1,N). 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RCOND  RCOND is DOUBLE PRECISION The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV). 
[out]  RESID  RESID is DOUBLE PRECISION norm(I  AINV*A) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 110 of file zget03.f.
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
ZGET04 computes the difference between a computed solution and the true solution to a system of linear equations. RESID = ( norm(XXACT) * RCOND ) / ( norm(XACT) * EPS ), where RCOND is the reciprocal of the condition number and EPS is the machine epsilon.
[in]  N  N is INTEGER The number of rows of the matrices X and XACT. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X and XACT. NRHS >= 0. 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). 
[in]  XACT  XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  RCOND  RCOND is DOUBLE PRECISION The reciprocal of the condition number of the coefficient matrix in the system of equations. 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the NRHS solution vectors of ( norm(XXACT) * RCOND ) / ( norm(XACT) * EPS ) 
Definition at line 103 of file zget04.f.
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
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 )
[in]  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) 
[in]  N  N is INTEGER The number of rows of the matrices X and XACT. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X and XACT. NRHS >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The original n by n matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[in]  B  B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). 
[in]  XACT  XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  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. 
[in]  CHKFERR  CHKFERR is LOGICAL Set to .TRUE. to check FERR, .FALSE. not to check FERR. When the test system is illconditioned, the "true" solution in XACT may be incorrect. 
[in]  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). 
[out]  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 + (*) ) 
Definition at line 166 of file zget07.f.
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
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.
[in]  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 
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The original M x N matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M). 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations. 
[in]  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). 
[in,out]  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. 
[in]  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). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 133 of file zget08.f.
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
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.
[in]  N  N is INTEGTER The order of the matrix A. N >= 0. 
[in]  DL  DL is COMPLEX*16 array, dimension (N1) The (n1) subdiagonal elements of A. 
[in]  D  D is COMPLEX*16 array, dimension (N) The diagonal elements of A. 
[in]  DU  DU is COMPLEX*16 array, dimension (N1) The (n1) superdiagonal elements of A. 
[in]  DLF  DLF is COMPLEX*16 array, dimension (N1) The (n1) multipliers that define the matrix L from the LU factorization of A. 
[in]  DF  DF is COMPLEX*16 array, dimension (N) The n diagonal elements of the upper triangular matrix U from the LU factorization of A. 
[in]  DUF  DUF is COMPLEX*16 array, dimension (N1) The (n1) elements of the first superdiagonal of U. 
[in]  DU2  DU2 is COMPLEX*16 array, dimension (N2) The (n2) elements of the second superdiagonal of U. 
[in]  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. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION The scaled residual: norm(L*U  A) / (norm(A) * EPS) 
Definition at line 134 of file zgtt01.f.
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
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.
[in]  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) 
[in]  N  N is INTEGTER The order of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0. 
[in]  DL  DL is COMPLEX*16 array, dimension (N1) The (n1) subdiagonal elements of A. 
[in]  D  D is COMPLEX*16 array, dimension (N) The diagonal elements of A. 
[in]  DU  DU is COMPLEX*16 array, dimension (N1) The (n1) superdiagonal elements of A. 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). 
[in,out]  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. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RESID  RESID is DOUBLE PRECISION norm(B  op(A)*X) / (norm(A) * norm(X) * EPS) 
Definition at line 124 of file zgtt02.f.
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
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
[in]  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) 
[in]  N  N is INTEGER The number of rows of the matrices X and XACT. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X and XACT. NRHS >= 0. 
[in]  DL  DL is COMPLEX*16 array, dimension (N1) The (n1) subdiagonal elements of A. 
[in]  D  D is COMPLEX*16 array, dimension (N) The diagonal elements of A. 
[in]  DU  DU is COMPLEX*16 array, dimension (N1) The (n1) superdiagonal elements of A. 
[in]  B  B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). 
[in]  XACT  XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  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. 
[in]  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). 
[out]  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 + (*) ) 
Definition at line 165 of file zgtt05.f.
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
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.
[in]  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 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The original Hermitian matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N) 
[in]  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. 
[in]  LDAFAC  LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,N). 
[in]  IPIV  IPIV is INTEGER array, dimension (N) The pivot indices from ZHETRF. 
[out]  C  C is COMPLEX*16 array, dimension (LDC,N) 
[in]  LDC  LDC is INTEGER The leading dimension of the array C. LDC >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  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 ) 
Definition at line 126 of file zhet01.f.
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
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.
[in]  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 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (N*(N+1)/2) The original Hermitian matrix A, stored as a packed triangular matrix. 
[in]  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. 
[in]  IPIV  IPIV is INTEGER array, dimension (N) The pivot indices from ZHPTRF. 
[out]  C  C is COMPLEX*16 array, dimension (LDC,N) 
[in]  LDC  LDC is INTEGER The leading dimension of the array C. LDC >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  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 ) 
Definition at line 114 of file zhpt01.f.
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
ZLAHILB generates an N by N scaled Hilbert matrix in A along with NRHS righthand sides in B and solutions in X such that A*X=B. The Hilbert matrix is scaled by M = LCM(1, 2, ..., 2*N1) so that all entries are integers. The righthand 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.
[in]  N  N is INTEGER The dimension of the matrix A. 
[in]  NRHS  NRHS is NRHS The requested number of righthand sides. 
[out]  A  A is COMPLEX array, dimension (LDA, N) The generated scaled Hilbert matrix. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= N. 
[out]  X  X is COMPLEX array, dimension (LDX, NRHS) The generated exact solutions. Currently, the first NRHS columns of the inverse Hilbert matrix. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= N. 
[out]  B  B is REAL array, dimension (LDB, NRHS) The generated righthand sides. Currently, the first NRHS columns of LCM(1, 2, ..., 2*N1) * the identity matrix. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= N. 
[out]  WORK  WORK is REAL array, dimension (N) 
[out]  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 ith argument had an illegal value 
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name. 
Definition at line 134 of file zlahilb.f.
subroutine zlaipd  (  integer  N, 
complex*16, dimension( * )  A,  
integer  INDA,  
integer  VINDA  
) 
ZLAIPD
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.
[in]  N  N is INTEGER The number of diagonal elements of A. 
[in,out]  A  A is COMPLEX*16 array, dimension (1+(N1)*INDA+(N2)*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. 
[in]  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) 
[in]  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 
Definition at line 84 of file zlaipd.f.
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
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.
[in]  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. 
[in]  N  N is INTEGER The order of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices X and B. 
[in]  ALPHA  ALPHA is DOUBLE PRECISION The scalar alpha. ALPHA must be 1. or 1.; otherwise, it is assumed to be 0. 
[in]  D  D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is COMPLEX*16 array, dimension (N1) The (n1) subdiagonal or superdiagonal elements of A. 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The N by NRHS matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(N,1). 
[in]  BETA  BETA is DOUBLE PRECISION The scalar beta. BETA must be 0., 1., or 1.; otherwise, it is assumed to be 1. 
[in,out]  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. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(N,1). 
Definition at line 129 of file zlaptm.f.
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
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).
[in]  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, 2D storage xPP: Hermitian positive definite packed xPB: Hermitian positive definite banded xHE: Hermitian indefinite, 2D storage xHP: Hermitian indefinite packed xHB: Hermitian indefinite banded xSY: Symmetric indefinite, 2D 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. 
[in]  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. 
[in]  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 
[in]  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 
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  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 <= M1. 
[in]  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 <= N1. If PATH = xTR, xTP, or xTB, specifies whether or not the matrix has unit diagonal: = 1: matrix has nonunit diagonal (default) = 2: matrix has unit diagonal 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors in the system A*X = B. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The test matrix whose type is given by PATH. 
[in]  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). 
[in,out]  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. 
[in]  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). 
[out]  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. 
[in]  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). 
[in,out]  ISEED  ISEED is INTEGER array, dimension (4) The seed vector for the random number generator (used in ZLATMS). Modified on exit. 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = k, the kth argument had an illegal value 
Definition at line 209 of file zlarhs.f.
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
ZLATB4 sets parameters for the matrix generator based on the type of matrix to be generated.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name. 
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  M  M is INTEGER The number of rows in the matrix to be generated. 
[in]  N  N is INTEGER The number of columns in the matrix to be generated. 
[out]  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 
[out]  KL  KL is INTEGER The lower band width of the matrix to be generated. 
[out]  KU  KU is INTEGER The upper band width of the matrix to be generated. 
[out]  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. 
[out]  MODE  MODE is INTEGER A key indicating how to choose the vector of eigenvalues. 
[out]  CNDNUM  CNDNUM is DOUBLE PRECISION The desired condition number. 
[out]  DIST  DIST is CHARACTER*1 The type of distribution to be used by the random number generator. 
Definition at line 120 of file zlatb4.f.
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
ZLATB5 sets parameters for the matrix generator based on the type of matrix to be generated.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name. 
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  N  N is INTEGER The number of rows and columns in the matrix to be generated. 
[out]  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 
[out]  KL  KL is INTEGER The lower band width of the matrix to be generated. 
[out]  KU  KU is INTEGER The upper band width of the matrix to be generated. 
[out]  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. 
[out]  MODE  MODE is INTEGER A key indicating how to choose the vector of eigenvalues. 
[out]  CNDNUM  CNDNUM is DOUBLE PRECISION The desired condition number. 
[out]  DIST  DIST is CHARACTER*1 The type of distribution to be used by the random number generator. 
Definition at line 114 of file zlatb5.f.
subroutine zlatsp  (  character  UPLO, 
integer  N,  
complex*16, dimension( * )  X,  
integer, dimension( * )  ISEED  
) 
ZLATSP
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 nondiagonalizable 2x2 block.
[in]  UPLO  UPLO is CHARACTER Specifies whether the generated matrix is to be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The dimension of the matrix to be generated. 
[out]  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. 
[in,out]  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) 
Definition at line 85 of file zlatsp.f.
subroutine zlatsy  (  character  UPLO, 
integer  N,  
complex*16, dimension( ldx, * )  X,  
integer  LDX,  
integer, dimension( * )  ISEED  
) 
ZLATSY
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 nondiagonalizable 2x2 block.
[in]  UPLO  UPLO is CHARACTER Specifies whether the generated matrix is to be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The dimension of the matrix to be generated. 
[out]  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. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. 
[in,out]  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) 
Definition at line 90 of file zlatsy.f.
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
ZLATTB generates a triangular test matrix in 2dimensional storage. IMAT and UPLO uniquely specify the properties of the test matrix, which is returned in the array A.
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the matrix A will be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  TRANS  TRANS is CHARACTER*1 Specifies whether the matrix or its transpose will be used. = 'N': No transpose = 'T': Transpose = 'C': Conjugate transpose (= transpose) 
[out]  DIAG  DIAG is CHARACTER*1 Specifies whether or not the matrix A is unit triangular. = 'N': Nonunit triangular = 'U': Unit triangular 
[in,out]  ISEED  ISEED is INTEGER array, dimension (4) The seed vector for the random number generator (used in ZLATMS). Modified on exit. 
[in]  N  N is INTEGER The order of the matrix to be generated. 
[in]  KD  KD is INTEGER The number of superdiagonals or subdiagonals of the banded triangular matrix A. KD >= 0. 
[out]  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+ij,j) = A(i,j) for max(1,jkd)<=i<=j. If UPLO = 'L', AB(1+ij,j) = A(i,j) for j<=i<=min(n,j+kd). 
[in]  LDAB  LDAB is INTEGER The leading dimension of the array AB. LDAB >= KD+1. 
[out]  B  B is COMPLEX*16 array, dimension (N) 
[out]  WORK  WORK is COMPLEX*16 array, dimension (2*N) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 141 of file zlattb.f.
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
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.
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the matrix A will be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  TRANS  TRANS is CHARACTER*1 Specifies whether the matrix or its transpose will be used. = 'N': No transpose = 'T': Transpose = 'C': Conjugate transpose 
[out]  DIAG  DIAG is CHARACTER*1 Specifies whether or not the matrix A is unit triangular. = 'N': Nonunit triangular = 'U': Unit triangular 
[in,out]  ISEED  ISEED is INTEGER array, dimension (4) The seed vector for the random number generator (used in ZLATMS). Modified on exit. 
[in]  N  N is INTEGER The order of the matrix to be generated. 
[out]  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 jth column of A is stored in the array AP as follows: if UPLO = 'U', AP((j1)*j/2 + i) = A(i,j) for 1<=i<=j; if UPLO = 'L', AP((j1)*(nj) + j*(j+1)/2 + ij) = A(i,j) for j<=i<=n. 
[out]  B  B is COMPLEX*16 array, dimension (N) The right hand side vector, if IMAT > 10. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (2*N) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 131 of file zlattp.f.
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
ZLATTR generates a triangular test matrix in 2dimensional storage. IMAT and UPLO uniquely specify the properties of the test matrix, which is returned in the array A.
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the matrix A will be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  TRANS  TRANS is CHARACTER*1 Specifies whether the matrix or its transpose will be used. = 'N': No transpose = 'T': Transpose = 'C': Conjugate transpose 
[out]  DIAG  DIAG is CHARACTER*1 Specifies whether or not the matrix A is unit triangular. = 'N': Nonunit triangular = 'U': Unit triangular 
[in,out]  ISEED  ISEED is INTEGER array, dimension (4) The seed vector for the random number generator (used in ZLATMS). Modified on exit. 
[in]  N  N is INTEGER The order of the matrix to be generated. 
[out]  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. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[out]  B  B is COMPLEX*16 array, dimension (N) The right hand side vector, if IMAT > 10. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (2*N) 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 138 of file zlattr.f.
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
ZLAVHE performs one of the matrixvector 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 ZHETRF. ZHETRF 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 in the leading upper or lower triangle of the 2D array A. If TRANS = 'N' or 'n', ZLAVHE multiplies either by U or U * D (or L or L * D). If TRANS = 'C' or 'c', ZLAVHE 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: DIAG = 'U' or 'u' Diagonal blocks are unit matrices. DIAG = 'N' or 'n' Diagonal blocks are nonunit. 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( LDA, N ) On entry, A contains a block diagonal matrix and the multipliers of the transformations used to obtain it, stored as a 2D triangular matrix. 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 max( 1, N ). Unchanged on exit. IPIV  INTEGER array, dimension( N ) On entry, IPIV contains the vector of pivot indices as determined by ZSYTRF or ZHETRF. 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 K1 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 Kth argument has an illegal value.
Definition at line 138 of file zlavhe.f.
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
ZLAVHP performs one of the matrixvector 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 nonunit. 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 K1 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 Kth argument has an illegal value.
Definition at line 131 of file zlavhp.f.
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
ZLAVSP performs one of the matrixvector 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 nonunit. 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 K1 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 Kth argument has an illegal value.
Definition at line 131 of file zlavsp.f.
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
ZLAVSY performs one of the matrixvector 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')
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the factor stored in A is upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  TRANS  TRANS is CHARACTER*1 Specifies the operation to be performed: = 'N': x := A*x = 'T': x := A'*x 
[in]  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 nonunit matrices. 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of vectors x to be multiplied by A. NRHS >= 0. 
[in]  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. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[in]  IPIV  IPIV is INTEGER array, dimension (N) Details of the interchanges and the block structure of D, as determined by ZSYTRF or ZHETRF. If UPLO = 'U': If IPIV(k) > 0, then rows and columns k and IPIV(k) were interchanged and D(k,k) is a 1by1 diagonal block. (If IPIV( k ) = k, no interchange was done). If IPIV(k) = IPIV(k1) < 0, then rows and columns k1 and IPIV(k) were interchanged, D(k1:k,k1:k) is a 2by2 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 1by1 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 2by2 diagonal block. 
[in,out]  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. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = k, the kth argument had an illegal value 
Definition at line 152 of file zlavsy.f.
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
ZLQT01 tests ZGELQF, which computes the LQ factorization of an mbyn matrix A, and partially tests ZUNGLQ which forms the nbyn orthogonal matrix Q. ZLQT01 compares L with A*Q', and checks that Q is orthogonal.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The mbyn matrix A. 
[out]  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. 
[out]  Q  Q is COMPLEX*16 array, dimension (LDA,N) The nbyn orthogonal matrix Q. 
[out]  L  L is COMPLEX*16 array, dimension (LDA,max(M,N)) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays A, AF, Q and L. LDA >= max(M,N). 
[out]  TAU  TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by ZGELQF. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (max(M,N)) 
[out]  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 ) 
Definition at line 126 of file zlqt01.f.
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
ZLQT02 tests ZUNGLQ, which generates an mbyn matrix Q with orthonornmal rows that is defined as the product of k elementary reflectors. Given the LQ factorization of an mbyn 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.
[in]  M  M is INTEGER The number of rows of the matrix Q to be generated. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix Q to be generated. N >= M >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the matrix Q. M >= K >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The mbyn matrix A which was factorized by ZLQT01. 
[in]  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. 
[out]  Q  Q is COMPLEX*16 array, dimension (LDA,N) 
[out]  L  L is COMPLEX*16 array, dimension (LDA,M) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays A, AF, Q and L. LDA >= N. 
[in]  TAU  TAU is COMPLEX*16 array, dimension (M) The scalar factors of the elementary reflectors corresponding to the LQ factorization in AF. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  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 ) 
Definition at line 135 of file zlqt02.f.
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
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.
[in]  M  M is INTEGER The number of rows or columns of the matrix C; C is nbym if Q is applied from the left, or mbyn if Q is applied from the right. M >= 0. 
[in]  N  N is INTEGER The order of the orthogonal matrix Q. N >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the orthogonal matrix Q. N >= K >= 0. 
[in]  AF  AF is COMPLEX*16 array, dimension (LDA,N) Details of the LQ factorization of an mbyn matrix, as returned by ZGELQF. See CGELQF for further details. 
[out]  C  C is COMPLEX*16 array, dimension (LDA,N) 
[out]  CC  CC is COMPLEX*16 array, dimension (LDA,N) 
[out]  Q  Q is COMPLEX*16 array, dimension (LDA,N) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q. 
[in]  TAU  TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the LQ factorization in AF. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  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. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an nbyn 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 ) 
Definition at line 136 of file zlqt03.f.
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
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.
[in]  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 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  KD  KD is INTEGER The number of superdiagonals of the matrix A if UPLO = 'U', or the number of subdiagonals if UPLO = 'L'. KD >= 0. 
[in]  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. 
[in]  LDA  LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,KD+1). 
[in]  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. 
[in]  LDAFAC  LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,KD+1). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  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 ) 
Definition at line 120 of file zpbt01.f.
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
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.
[in]  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 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  KD  KD is INTEGER The number of superdiagonals of the matrix A if UPLO = 'U', or the number of subdiagonals if UPLO = 'L'. KD >= 0. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides. NRHS >= 0. 
[in]  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. 
[in]  LDA  LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,KD+1). 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). 
[in,out]  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. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 136 of file zpbt02.f.
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
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
[in]  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 
[in]  N  N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0. 
[in]  KD  KD is INTEGER The number of superdiagonals of the matrix A if UPLO = 'U', or the number of subdiagonals if UPLO = 'L'. KD >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0. 
[in]  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 jth column of A is stored in the jth column of the array AB as follows: if UPLO = 'U', AB(kd+1+ij,j) = A(i,j) for max(1,jkd)<=i<=j; if UPLO = 'L', AB(1+ij,j) = A(i,j) for j<=i<=min(n,j+kd). 
[in]  LDAB  LDAB is INTEGER The leading dimension of the array AB. LDAB >= KD+1. 
[in]  B  B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). 
[in]  XACT  XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  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. 
[in]  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). 
[out]  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 + (*) ) 
Definition at line 171 of file zpbt05.f.
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
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.
[in]  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 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The original Hermitian matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N) 
[in,out]  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). 
[in]  LDAFAC  LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  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 ) 
Definition at line 107 of file zpot01.f.
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
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.
[in]  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 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The original Hermitian matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N) 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). 
[in,out]  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. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 127 of file zpot02.f.
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
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.
[in]  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 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The original Hermitian matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N) 
[in,out]  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. 
[in]  LDAINV  LDAINV is INTEGER The leading dimension of the array AINV. LDAINV >= max(1,N). 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RCOND  RCOND is DOUBLE PRECISION The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV). 
[out]  RESID  RESID is DOUBLE PRECISION norm(I  A*AINV) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 126 of file zpot03.f.
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
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 )
[in]  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 
[in]  N  N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0. 
[in]  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. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[in]  B  B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). 
[in]  XACT  XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  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. 
[in]  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). 
[out]  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 + (*) ) 
Definition at line 165 of file zpot05.f.
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
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.
[in]  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 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The original M x N matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N). 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations. 
[in]  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). 
[in,out]  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. 
[in]  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). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 127 of file zpot06.f.
subroutine zppt01  (  character  UPLO, 
integer  N,  
complex*16, dimension( * )  A,  
complex*16, dimension( * )  AFAC,  
double precision, dimension( * )  RWORK,  
double precision  RESID  
) 
ZPPT01
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.
[in]  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 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (N*(N+1)/2) The original Hermitian matrix A, stored as a packed triangular matrix. 
[in,out]  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). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  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 ) 
Definition at line 96 of file zppt01.f.
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
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.
[in]  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 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (N*(N+1)/2) The original Hermitian matrix A, stored as a packed triangular matrix. 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). 
[in,out]  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. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RESID  RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 123 of file zppt02.f.
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
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.
[in]  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 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (N*(N+1)/2) The original Hermitian matrix A, stored as a packed triangular matrix. 
[in]  AINV  AINV is COMPLEX*16 array, dimension (N*(N+1)/2) The (Hermitian) inverse of the matrix A, stored as a packed triangular matrix. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  RCOND  RCOND is DOUBLE PRECISION The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV). 
[out]  RESID  RESID is DOUBLE PRECISION norm(I  A*AINV) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 110 of file zppt03.f.
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
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 )
[in]  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 
[in]  N  N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0. 
[in]  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 jth column of A is stored in the array AP as follows: if UPLO = 'U', AP(i + (j1)*j/2) = A(i,j) for 1<=i<=j; if UPLO = 'L', AP(i + (j1)*(2nj)/2) = A(i,j) for j<=i<=n. 
[in]  B  B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). 
[in]  XACT  XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  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. 
[in]  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). 
[out]  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 + (*) ) 
Definition at line 157 of file zppt05.f.
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
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.
[in]  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 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The original Hermitian matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N) 
[in]  AFAC  AFAC is COMPLEX*16 array, dimension (LDAFAC,N) The factor L or U from the L*L' or U'*U factorization of A. 
[in]  LDAFAC  LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,N). 
[out]  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) 
[in]  LDPERM  LDPERM is INTEGER The leading dimension of the array PERM. LDAPERM >= max(1,N). 
[in]  PIV  PIV is INTEGER array, dimension (N) PIV is such that the nonzero entries are P( PIV( K ), K ) = 1. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (N) 
[out]  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 ) 
[in]  RANK  RANK is INTEGER number of nonzero singular values of A. 
Definition at line 136 of file zpst01.f.
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
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.
[in]  N  N is INTEGTER The order of the matrix A. 
[in]  D  D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is COMPLEX*16 array, dimension (N1) The (n1) subdiagonal elements of the tridiagonal matrix A. 
[in]  DF  DF is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the factor L from the L*D*L' factorization of A. 
[in]  EF  EF is COMPLEX*16 array, dimension (N1) The (n1) subdiagonal elements of the factor L from the L*D*L' factorization of A. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (2*N) 
[out]  RESID  RESID is DOUBLE PRECISION norm(L*D*L'  A) / (n * norm(A) * EPS) 
Definition at line 93 of file zptt01.f.
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
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.
[in]  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 
[in]  N  N is INTEGTER The order of the matrix A. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0. 
[in]  D  D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is COMPLEX*16 array, dimension (N1) The (n1) subdiagonal elements of the tridiagonal matrix A. 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The n by nrhs matrix of solution vectors X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). 
[in,out]  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. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  RESID  RESID is DOUBLE PRECISION norm(B  A*X) / (norm(A) * norm(X) * EPS) 
Definition at line 116 of file zptt02.f.
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
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
[in]  N  N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0. 
[in]  D  D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is COMPLEX*16 array, dimension (N1) The (n1) subdiagonal elements of the tridiagonal matrix A. 
[in]  B  B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N). 
[in]  XACT  XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT. 
[in]  LDXACT  LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N). 
[in]  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. 
[in]  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). 
[out]  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 + (*) ) 
Definition at line 150 of file zptt05.f.
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
ZQLT01 tests ZGEQLF, which computes the QL factorization of an mbyn matrix A, and partially tests ZUNGQL which forms the mbym orthogonal matrix Q. ZQLT01 compares L with Q'*A, and checks that Q is orthogonal.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The mbyn matrix A. 
[out]  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. 
[out]  Q  Q is COMPLEX*16 array, dimension (LDA,M) The mbym orthogonal matrix Q. 
[out]  L  L is COMPLEX*16 array, dimension (LDA,max(M,N)) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays A, AF, Q and R. LDA >= max(M,N). 
[out]  TAU  TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by ZGEQLF. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  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 ) 
Definition at line 126 of file zqlt01.f.
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
ZQLT02 tests ZUNGQL, which generates an mbyn matrix Q with orthonornmal columns that is defined as the product of k elementary reflectors. Given the QL factorization of an mbyn matrix A, ZQLT02 generates the orthogonal matrix Q defined by the factorization of the last k columns of A; it compares L(mn+1:m,nk+1:n) with Q(1:m,mn+1:m)'*A(1:m,nk+1:n), and checks that the columns of Q are orthonormal.
[in]  M  M is INTEGER The number of rows of the matrix Q to be generated. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix Q to be generated. M >= N >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The mbyn matrix A which was factorized by ZQLT01. 
[in]  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. 
[out]  Q  Q is COMPLEX*16 array, dimension (LDA,N) 
[out]  L  L is COMPLEX*16 array, dimension (LDA,N) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays A, AF, Q and L. LDA >= M. 
[in]  TAU  TAU is COMPLEX*16 array, dimension (N) The scalar factors of the elementary reflectors corresponding to the QL factorization in AF. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  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 ) 
Definition at line 136 of file zqlt02.f.
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
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.
[in]  M  M is INTEGER The order of the orthogonal matrix Q. M >= 0. 
[in]  N  N is INTEGER The number of rows or columns of the matrix C; C is mbyn if Q is applied from the left, or nbym if Q is applied from the right. N >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the orthogonal matrix Q. M >= K >= 0. 
[in]  AF  AF is COMPLEX*16 array, dimension (LDA,N) Details of the QL factorization of an mbyn matrix, as returned by ZGEQLF. See CGEQLF for further details. 
[out]  C  C is COMPLEX*16 array, dimension (LDA,N) 
[out]  CC  CC is COMPLEX*16 array, dimension (LDA,N) 
[out]  Q  Q is COMPLEX*16 array, dimension (LDA,M) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q. 
[in]  TAU  TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the QL factorization in AF. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  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. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an mbym 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 ) 
Definition at line 136 of file zqlt03.f.
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
ZQPT01 tests the QRfactorization with pivoting of a matrix A. The array AF contains the (possibly partial) QRfactorization 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)
[in]  M  M is INTEGER The number of rows of the matrices A and AF. 
[in]  N  N is INTEGER The number of columns of the matrices A and AF. 
[in]  K  K is INTEGER The number of columns of AF that have been reduced to upper triangular form. 
[in]  A  A is COMPLEX*16 array, dimension (LDA, N) The original matrix A. 
[in]  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. 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays A and AF. 
[in]  TAU  TAU is COMPLEX*16 array, dimension (K) Details of the Householder transformations as returned by ZGEQPF. 
[in]  JPVT  JPVT is INTEGER array, dimension (N) Pivot information as returned by ZGEQPF. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= M*N+N. 
Definition at line 120 of file zqpt01.f.
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
ZQRT01 tests ZGEQRF, which computes the QR factorization of an mbyn matrix A, and partially tests ZUNGQR which forms the mbym orthogonal matrix Q. ZQRT01 compares R with Q'*A, and checks that Q is orthogonal.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The mbyn matrix A. 
[out]  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. 
[out]  Q  Q is COMPLEX*16 array, dimension (LDA,M) The mbym orthogonal matrix Q. 
[out]  R  R is COMPLEX*16 array, dimension (LDA,max(M,N)) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays A, AF, Q and R. LDA >= max(M,N). 
[out]  TAU  TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by ZGEQRF. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  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 ) 
Definition at line 126 of file zqrt01.f.
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
ZQRT01P tests ZGEQRFP, which computes the QR factorization of an mbyn matrix A, and partially tests ZUNGQR which forms the mbym orthogonal matrix Q. ZQRT01P compares R with Q'*A, and checks that Q is orthogonal.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The mbyn matrix A. 
[out]  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. 
[out]  Q  Q is COMPLEX*16 array, dimension (LDA,M) The mbym orthogonal matrix Q. 
[out]  R  R is COMPLEX*16 array, dimension (LDA,max(M,N)) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays A, AF, Q and R. LDA >= max(M,N). 
[out]  TAU  TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by ZGEQRFP. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  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 ) 
Definition at line 126 of file zqrt01p.f.
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
ZQRT02 tests ZUNGQR, which generates an mbyn matrix Q with orthonornmal columns that is defined as the product of k elementary reflectors. Given the QR factorization of an mbyn 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.
[in]  M  M is INTEGER The number of rows of the matrix Q to be generated. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix Q to be generated. M >= N >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The mbyn matrix A which was factorized by ZQRT01. 
[in]  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. 
[out]  Q  Q is COMPLEX*16 array, dimension (LDA,N) 
[out]  R  R is COMPLEX*16 array, dimension (LDA,N) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays A, AF, Q and R. LDA >= M. 
[in]  TAU  TAU is COMPLEX*16 array, dimension (N) The scalar factors of the elementary reflectors corresponding to the QR factorization in AF. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  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 ) 
Definition at line 135 of file zqrt02.f.
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
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.
[in]  M  M is INTEGER The order of the orthogonal matrix Q. M >= 0. 
[in]  N  N is INTEGER The number of rows or columns of the matrix C; C is mbyn if Q is applied from the left, or nbym if Q is applied from the right. N >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the orthogonal matrix Q. M >= K >= 0. 
[in]  AF  AF is COMPLEX*16 array, dimension (LDA,N) Details of the QR factorization of an mbyn matrix, as returnedby ZGEQRF. See CGEQRF for further details. 
[out]  C  C is COMPLEX*16 array, dimension (LDA,N) 
[out]  CC  CC is COMPLEX*16 array, dimension (LDA,N) 
[out]  Q  Q is COMPLEX*16 array, dimension (LDA,M) 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q. 
[in]  TAU  TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the QR factorization in AF. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  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. 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  RESULT  RESULT is DOUBLE PRECISION array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an mbym 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 ) 
Definition at line 136 of file zqrt03.f.
subroutine zqrt04  (  integer  M, 
integer  N,  
integer  NB,  
double precision, dimension(6)  RESULT  
) 
ZQRT04
ZQRT04 tests ZGEQRT and ZGEMQRT.
[in]  M  M is INTEGER Number of rows in test matrix. 
[in]  N  N is INTEGER Number of columns in test matrix. 
[in]  NB  NB is INTEGER Block size of test matrix. NB <= Min(M,N). 
[out]  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  
Definition at line 74 of file zqrt04.f.
subroutine zqrt05  (  integer  M, 
integer  N,  
integer  L,  
integer  NB,  
double precision, dimension(6)  RESULT  
) 
ZQRT05
ZQRT05 tests ZTPQRT and ZTPMQRT.
[in]  M  M is INTEGER Number of rows in lower part of the test matrix. 
[in]  N  N is INTEGER Number of columns in test matrix. 
[in]  L  L is INTEGER The number of rows of the upper trapezoidal part the lower test matrix. 0 <= L <= M. 
[in]  NB  NB is INTEGER Block size of test matrix. NB <= N. 
[out]  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  
Definition at line 81 of file zqrt05.f.
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
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 mvector of the form [ 0 ... 0 1 x(k) ]', where x(k) is a vector of length mk stored in A(k+1:m,k).
[in]  M  M is INTEGER The number of rows of the matrix A. 
[in]  K  K is INTEGER The number of columns of A whose subdiagonal entries contain information about orthogonal transformations. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,K) The (possibly partial) output of a QR reduction routine. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[in]  TAU  TAU is COMPLEX*16 array, dimension (K) The scaling factors tau for the elementary transformations as computed by the QR factorization routine. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= M*M + M. 
Definition at line 99 of file zqrt11.f.
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
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))
[in]  M  M is INTEGER The number of rows of the matrix A. 
[in]  N  N is INTEGER The number of columns of the matrix A. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The MbyN matrix A. Only the upper trapezoid is referenced. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[in]  S  S is DOUBLE PRECISION array, dimension (min(M,N)) The singular values of the matrix A. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= M*N + 2*min(M,N) + max(M,N). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (2*min(M,N)) 
Definition at line 97 of file zqrt12.f.
subroutine zqrt13  (  integer  SCALE, 
integer  M,  
integer  N,  
complex*16, dimension( lda, * )  A,  
integer  LDA,  
double precision  NORMA,  
integer, dimension( 4 )  ISEED  
) 
ZQRT13
ZQRT13 generates a fullrank matrix that may be scaled to have large or small norm.
[in]  SCALE  SCALE is INTEGER SCALE = 1: normally scaled matrix SCALE = 2: matrix scaled up SCALE = 3: matrix scaled down 
[in]  M  M is INTEGER The number of rows of the matrix A. 
[in]  N  N is INTEGER The number of columns of A. 
[out]  A  A is COMPLEX*16 array, dimension (LDA,N) The MbyN matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[out]  NORMA  NORMA is DOUBLE PRECISION The onenorm of A. 
[in,out]  ISEED  ISEED is integer array, dimension (4) Seed for random number generator 
Definition at line 92 of file zqrt13.f.
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
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.
[in]  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'. 
[in]  M  M is INTEGER The number of rows of the matrix A. 
[in]  N  N is INTEGER The number of columns of the matrix A. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of columns of X. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The MbyN matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) If TRANS = 'N', the NbyNRHS matrix X. IF TRANS = 'C', the MbyNRHS matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. 
[out]  WORK  WORK is COMPLEX*16 array dimension (LWORK) 
[in]  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). 
Definition at line 116 of file zqrt14.f.
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
ZQRT15 generates a matrix with full or deficient rank and of various norms.
[in]  SCALE  SCALE is INTEGER SCALE = 1: normally scaled matrix SCALE = 2: matrix scaled up SCALE = 3: matrix scaled down 
[in]  RKSEL  RKSEL is INTEGER RKSEL = 1: full rank matrix RKSEL = 2: rankdeficient matrix 
[in]  M  M is INTEGER The number of rows of the matrix A. 
[in]  N  N is INTEGER The number of columns of A. 
[in]  NRHS  NRHS is INTEGER The number of columns of B. 
[out]  A  A is COMPLEX*16 array, dimension (LDA,N) The MbyN matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[out]  B  B is COMPLEX*16 array, dimension (LDB, NRHS) A matrix that is in the range space of matrix A. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. 
[out]  S  S is DOUBLE PRECISION array, dimension MIN(M,N) Singular values of A. 
[out]  RANK  RANK is INTEGER number of nonzero singular values of A. 
[out]  NORMA  NORMA is DOUBLE PRECISION onenorm norm of A. 
[out]  NORMB  NORMB is DOUBLE PRECISION onenorm norm of B. 
[in,out]  ISEED  ISEED is integer array, dimension (4) seed for random number generator. 
[out]  WORK  WORK is COMPLEX*16 array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER length of work space required. LWORK >= MAX(M+MIN(M,N),NRHS*MIN(M,N),2*N+M) 
Definition at line 149 of file zqrt15.f.
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
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.
[in]  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 
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The original M x N matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M). 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations. 
[in]  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). 
[in,out]  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. 
[in]  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). 
[out]  RWORK  RWORK is DOUBLE PRECISION array, dimension (M) 
[out]  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 ). 
Definition at line 133 of file zqrt16.f.
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
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 (zeroresidual problem) alpha = R if IRESID = 2 (otherwise).
[in]  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'. 
[in]  IRESID  IRESID is INTEGER IRESID = 1 indicates zeroresidual problem. IRESID = 2 indicates nonzero residual. 
[in]  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. 
[in]  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. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X and B. 
[in]  A  A is COMPLEX*16 array, dimension (LDA,N) The mbyn matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  X  X is COMPLEX*16 array, dimension (LDX,NRHS) If TRANS = 'N', the nbynrhs matrix X. If TRANS = 'C', the mbynrhs matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. If TRANS = 'N', LDX >= N. If TRANS = 'C', LDX >= M. 
[in]  B  B is COMPLEX*16 array, dimension (LDB,NRHS) If T 