complex16_lin(3) complex16

Functions


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

Detailed Description

This is the group of complex16 LAPACK TESTING LIN routines.

Function Documentation

program zchkaa ()

ZCHKAA

Purpose:

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


 

  NMAX    INTEGER
          The maximum allowable value for M and N.
  MAXIN   INTEGER
          The number of different values that can be used for each of
          M, N, NRHS, NB, NX and RANK
  MAXRHS  INTEGER
          The maximum number of right hand sides
  MATMAX  INTEGER
          The maximum number of matrix types to use for testing
  NIN     INTEGER
          The unit number for input
  NOUT    INTEGER
          The unit number for output


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

program zchkab ()

ZCHKAB

Purpose:

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


 

  NMAX    INTEGER
          The maximum allowable value for N
  MAXIN   INTEGER
          The number of different values that can be used for each of
          M, N, NRHS, NB, and NX
  MAXRHS  INTEGER
          The maximum number of right hand sides
  NIN     INTEGER
          The unit number for input
  NOUT    INTEGER
          The unit number for output


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

subroutine zchkeq (double precision THRESH, integer NOUT)

ZCHKEQ

Purpose:

 ZCHKEQ tests ZGEEQU, ZGBEQU, ZPOEQU, ZPPEQU and ZPBEQU


 

Parameters:

THRESH

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKGB

Purpose:

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


 

Parameters:

DOTYPE

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


NM

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


MVAL

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


A

          A is COMPLEX*16 array, dimension (LA)


LA

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


AFAC

          AFAC is COMPLEX*16 array, dimension (LAFAC)


LAFAC

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKGE

Purpose:

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


 

Parameters:

DOTYPE

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


NM

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


MVAL

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKGT

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


A

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


AF

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKHE

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

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

ZCHKHE_ROOK

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (2*NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

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

ZCHKHP

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKLQ

Purpose:

 ZCHKLQ tests ZGELQF, ZUNGLQ and CUNMLQ.


 

Parameters:

DOTYPE

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


NM

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


MVAL

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NXVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AF

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


AQ

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


AL

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


AC

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


B

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


X

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


XACT

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


TAU

          TAU is COMPLEX*16 array, dimension (NMAX)


WORK

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


RWORK

          RWORK is DOUBLE PRECISION array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKPB

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKPO

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKPP

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKPS

Purpose:

 ZCHKPS tests ZPSTRF.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NRANK

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


RANKVAL

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


PERM

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


PIV

          PIV is INTEGER array, dimension (NMAX)


WORK

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


RWORK

          RWORK is DOUBLE PRECISION array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKPT

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


A

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


D

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


E

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKQ3

Purpose:

 ZCHKQ3 tests ZGEQP3.


 

Parameters:

DOTYPE

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


NM

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


MVAL

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NXVAL

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


THRESH

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


A

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


COPYA

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


S

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


TAU

          TAU is COMPLEX*16 array, dimension (MMAX)


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (2*NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKQL

Purpose:

 ZCHKQL tests ZGEQLF, ZUNGQL and CUNMQL.


 

Parameters:

DOTYPE

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


NM

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


MVAL

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NXVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AF

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


AQ

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


AL

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


AC

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


B

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


X

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


XACT

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


TAU

          TAU is COMPLEX*16 array, dimension (NMAX)


WORK

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


RWORK

          RWORK is DOUBLE PRECISION array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKQR

Purpose:

 ZCHKQR tests ZGEQRF, ZUNGQR and CUNMQR.


 

Parameters:

DOTYPE

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


NM

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


MVAL

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NXVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AF

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


AQ

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


AR

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


AC

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


B

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


X

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


XACT

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


TAU

          TAU is COMPLEX*16 array, dimension (NMAX)


WORK

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


RWORK

          RWORK is DOUBLE PRECISION array, dimension (NMAX)


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

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

ZCHKQRT

Purpose:

 ZCHKQRT tests ZGEQRT and ZGEMQRT.


 

Parameters:

THRESH

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


TSTERR

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


NM

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


MVAL

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKQRTP

Purpose:

 ZCHKQRTP tests ZTPQRT and ZTPMQRT.


 

Parameters:

THRESH

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


TSTERR

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


NM

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


MVAL

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

program zchkrfp ()

ZCHKRFP

Purpose:

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


 

  MAXIN   INTEGER
          The number of different values that can be used for each of
          M, N, or NB
  MAXRHS  INTEGER
          The maximum number of right hand sides
  NTYPES  INTEGER
  NMAX    INTEGER
          The maximum allowable value for N.
  NIN     INTEGER
          The unit number for input
  NOUT    INTEGER
          The unit number for output


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

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

ZCHKRQ

Purpose:

 ZCHKRQ tests ZGERQF, ZUNGRQ and CUNMRQ.


 

Parameters:

DOTYPE

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


NM

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


MVAL

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NXVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AF

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


AQ

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


AR

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


AC

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


B

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


X

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


XACT

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


TAU

          TAU is COMPLEX*16 array, dimension (NMAX)


WORK

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


RWORK

          RWORK is DOUBLE PRECISION array, dimension (NMAX)


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKSP

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKSY

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

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

ZCHKSY_ROOK

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (2*NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

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

ZCHKTB

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


NMAX

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


AB

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKTP

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


NMAX

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


AP

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


AINVP

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKTR

Purpose:

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


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZCHKTZ

Purpose:

 ZCHKTZ tests ZTZRZF.


 

Parameters:

DOTYPE

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


NM

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


MVAL

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


NN

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


NVAL

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


THRESH

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


TSTERR

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


A

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


COPYA

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


S

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


TAU

          TAU is COMPLEX*16 array, dimension (MMAX)


WORK

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


RWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

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

ZDRVAB

Purpose:

 ZDRVAB tests ZCGESV


 

Parameters:

DOTYPE

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


NM

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


MVAL

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


NNS

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


NSVAL

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


THRESH

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


NMAX

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


A

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


AFAC

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


B

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


X

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


WORK

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


RWORK

          RWORK is DOUBLE PRECISION array, dimension
                      NMAX


SWORK

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


IWORK

          IWORK is INTEGER array, dimension
                      NMAX


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZDRVAC

Purpose:

 ZDRVAC tests ZCPOSV.


 

Parameters:

DOTYPE

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


NM

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


MVAL

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


NNS

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


NSVAL

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


THRESH

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


NMAX

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


A

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


AFAC

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


B

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


X

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


WORK

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


RWORK

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


SWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZDRVGB ZDRVGBX

Purpose:

 ZDRVGB tests the driver routines ZGBSV and -SVX.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


A

          A is COMPLEX*16 array, dimension (LA)


LA

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


AFB

          AFB is COMPLEX*16 array, dimension (LAFB)


LAFB

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


ASAV

          ASAV is COMPLEX*16 array, dimension (LA)


B

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


BSAV

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


X

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


XACT

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


S

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

Purpose:

 ZDRVGB tests the driver routines ZGBSV, -SVX, and -SVXX.
 Note that this file is used only when the XBLAS are available,
 otherwise zdrvgb.f defines this subroutine.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


A

          A is COMPLEX*16 array, dimension (LA)


LA

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


AFB

          AFB is COMPLEX*16 array, dimension (LAFB)


LAFB

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


ASAV

          ASAV is COMPLEX*16 array, dimension (LA)


B

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


BSAV

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


X

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


XACT

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


S

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZDRVGE ZDRVGEX

Purpose:

 ZDRVGE tests the driver routines ZGESV and -SVX.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


ASAV

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


B

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


BSAV

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


X

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


XACT

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


S

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

Purpose:

 ZDRVGE tests the driver routines ZGESV, -SVX, and -SVXX.
 Note that this file is used only when the XBLAS are available,
 otherwise zdrvge.f defines this subroutine.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


ASAV

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


B

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


BSAV

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


X

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


XACT

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


S

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

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

ZDRVGT

Purpose:

 ZDRVGT tests ZGTSV and -SVX.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


A

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


AF

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (2*NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZDRVHE ZDRVHEX

Purpose:

 ZDRVHE tests the driver routines ZHESV and -SVX.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

Purpose:

 ZDRVHE tests the driver routines ZHESV, -SVX, and -SVXX.
 Note that this file is used only when the XBLAS are available,
 otherwise zdrvhe.f defines this subroutine.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

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

ZDRVHE_ROOK

Purpose:

 ZDRVHE_ROOK tests the driver routines ZHESV_ROOK.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

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

ZDRVHP

Purpose:

 ZDRVHP tests the driver routines ZHPSV and -SVX.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZDRVLS

Purpose:

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


 

Parameters:

DOTYPE

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


NM

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


MVAL

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


NN

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


NVAL

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


NNB

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


NBVAL

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


NXVAL

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


NNS

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


NSVAL

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


THRESH

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


TSTERR

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


A

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


COPYA

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


B

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


COPYB

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


C

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


S

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


COPYS

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


WORK

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


RWORK

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


IWORK

          IWORK is INTEGER array, dimension (15*NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

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

ZDRVPB

Purpose:

 ZDRVPB tests the driver routines ZPBSV and -SVX.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


ASAV

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


B

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


BSAV

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


X

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


XACT

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


S

          S is DOUBLE PRECISION array, dimension (NMAX)


WORK

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


RWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZDRVPO ZDRVPOX

Purpose:

 ZDRVPO tests the driver routines ZPOSV and -SVX.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


ASAV

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


B

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


BSAV

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


X

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


XACT

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


S

          S is DOUBLE PRECISION array, dimension (NMAX)


WORK

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


RWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Purpose:

 ZDRVPO tests the driver routines ZPOSV, -SVX, and -SVXX.
 Note that this file is used only when the XBLAS are available,
 otherwise zdrvpo.f defines this subroutine.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


ASAV

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


B

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


BSAV

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


X

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


XACT

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


S

          S is DOUBLE PRECISION array, dimension (NMAX)


WORK

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


RWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

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

ZDRVPP

Purpose:

 ZDRVPP tests the driver routines ZPPSV and -SVX.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


ASAV

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


B

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


BSAV

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


X

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


XACT

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


S

          S is DOUBLE PRECISION array, dimension (NMAX)


WORK

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


RWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZDRVPT

Purpose:

 ZDRVPT tests ZPTSV and -SVX.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


A

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


D

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


E

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


B

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


X

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


XACT

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


WORK

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


RWORK

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


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZDRVRF1

Purpose:

 ZDRVRF1 tests the LAPACK RFP routines:
     ZLANHF.F


 

Parameters:

NOUT

          NOUT is INTEGER
                The unit number for output.


NN

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


NVAL

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


THRESH

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


A

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


LDA

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


ARF

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


WORK

          WORK is DOUBLE PRECISION array, dimension ( NMAX )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZDRVRF2

Purpose:

 ZDRVRF2 tests the LAPACK RFP conversion routines.


 

Parameters:

NOUT

          NOUT is INTEGER
                The unit number for output.


NN

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


NVAL

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


A

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


LDA

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


ARF

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


AP

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


ASAV

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


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZDRVRF3

Purpose:

 ZDRVRF3 tests the LAPACK RFP routines:
     ZTFSM


 

Parameters:

NOUT

          NOUT is INTEGER
                The unit number for output.


NN

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


NVAL

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


THRESH

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


A

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


LDA

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


ARF

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


B1

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


B2

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


D_WORK_ZLANGE

          D_WORK_ZLANGE is DOUBLE PRECISION array, dimension (NMAX)


Z_WORK_ZGEQRF

          Z_WORK_ZGEQRF is COMPLEX*16 array, dimension (NMAX)


TAU

          TAU is COMPLEX*16 array, dimension (NMAX)


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZDRVRF4

Purpose:

 ZDRVRF4 tests the LAPACK RFP routines:
     ZHFRK


 

Parameters:

NOUT

          NOUT is INTEGER
                The unit number for output.


NN

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


NVAL

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


THRESH

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


C1

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


C2

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


LDC

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


CRF

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


A

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


LDA

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


D_WORK_ZLANGE

          D_WORK_ZLANGE is DOUBLE PRECISION array, dimension (NMAX)


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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

ZDRVRFP

Purpose:

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


 

Parameters:

NOUT

          NOUT is INTEGER
                The unit number for output.


NN

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


NVAL

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


NNS

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


NSVAL

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


NNT

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


NTVAL

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


THRESH

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


A

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


ASAV

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


AFAC

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


AINV

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


B

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


BSAV

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


XACT

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


X

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


ARF

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


ARFINV

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


Z_WORK_ZLATMS

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


Z_WORK_ZPOT02

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


Z_WORK_ZPOT03

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


D_WORK_ZLATMS

          D_WORK_ZLATMS is DOUBLE PRECISION array, dimension ( NMAX )


D_WORK_ZLANHE

          D_WORK_ZLANHE is DOUBLE PRECISION array, dimension ( NMAX )


D_WORK_ZPOT01

          D_WORK_ZPOT01 is DOUBLE PRECISION array, dimension ( NMAX )


D_WORK_ZPOT02

          D_WORK_ZPOT02 is DOUBLE PRECISION array, dimension ( NMAX )


D_WORK_ZPOT03

          D_WORK_ZPOT03 is DOUBLE PRECISION array, dimension ( NMAX )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

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

ZDRVSP

Purpose:

 ZDRVSP tests the driver routines ZSPSV and -SVX.


 

Parameters:

DOTYPE

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


NN

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


NVAL

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


NRHS

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


THRESH

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


TSTERR

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


NMAX

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


A

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


AFAC

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


AINV

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


B

          B is COMPLEX*16 array, dimension (NMAX*NRHS)


X

          X is COMPLEX*16 array, dimension (NMAX*NRHS)


XACT

          XACT is COMPLEX*16 array, dimension (NMAX*NRHS)


WORK

          WORK is COMPLEX*16 array, dimension
                      (NMAX*max(2,NRHS))


RWORK

          RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zdrvsy (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL, integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)

ZDRVSY ZDRVSYX

Purpose:

 ZDRVSY tests the driver routines ZSYSV and -SVX.


 

Parameters:

DOTYPE

          DOTYPE is LOGICAL array, dimension (NTYPES)
          The matrix types to be used for testing.  Matrices of type j
          (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
          .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.


NN

          NN is INTEGER
          The number of values of N contained in the vector NVAL.


NVAL

          NVAL is INTEGER array, dimension (NN)
          The values of the matrix dimension N.


NRHS

          NRHS is INTEGER
          The number of right hand side vectors to be generated for
          each linear system.


THRESH

          THRESH is DOUBLE PRECISION
          The threshold value for the test ratios.  A result is
          included in the output file if RESULT >= THRESH.  To have
          every test ratio printed, use THRESH = 0.


TSTERR

          TSTERR is LOGICAL
          Flag that indicates whether error exits are to be tested.


NMAX

          NMAX is INTEGER
          The maximum value permitted for N, used in dimensioning the
          work arrays.


A

          A is COMPLEX*16 array, dimension (NMAX*NMAX)


AFAC

          AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)


AINV

          AINV is COMPLEX*16 array, dimension (NMAX*NMAX)


B

          B is COMPLEX*16 array, dimension (NMAX*NRHS)


X

          X is COMPLEX*16 array, dimension (NMAX*NRHS)


XACT

          XACT is COMPLEX*16 array, dimension (NMAX*NRHS)


WORK

          WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))


RWORK

          RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

Purpose:

 ZDRVSY tests the driver routines ZSYSV, -SVX, and -SVXX.
 Note that this file is used only when the XBLAS are available,
 otherwise zdrvsy.f defines this subroutine.


 

Parameters:

DOTYPE

          DOTYPE is LOGICAL array, dimension (NTYPES)
          The matrix types to be used for testing.  Matrices of type j
          (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
          .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.


NN

          NN is INTEGER
          The number of values of N contained in the vector NVAL.


NVAL

          NVAL is INTEGER array, dimension (NN)
          The values of the matrix dimension N.


NRHS

          NRHS is INTEGER
          The number of right hand side vectors to be generated for
          each linear system.


THRESH

          THRESH is DOUBLE PRECISION
          The threshold value for the test ratios.  A result is
          included in the output file if RESULT >= THRESH.  To have
          every test ratio printed, use THRESH = 0.


TSTERR

          TSTERR is LOGICAL
          Flag that indicates whether error exits are to be tested.


NMAX

          NMAX is INTEGER
          The maximum value permitted for N, used in dimensioning the
          work arrays.


A

          A is COMPLEX*16 array, dimension (NMAX*NMAX)


AFAC

          AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)


AINV

          AINV is COMPLEX*16 array, dimension (NMAX*NMAX)


B

          B is COMPLEX*16 array, dimension (NMAX*NRHS)


X

          X is COMPLEX*16 array, dimension (NMAX*NRHS)


XACT

          XACT is COMPLEX*16 array, dimension (NMAX*NRHS)


WORK

          WORK is COMPLEX*16 array, dimension
                      (NMAX*max(2,NRHS))


RWORK

          RWORK is DOUBLE PRECISION array, dimension (2*NMAX+2*NRHS)


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

subroutine zdrvsy_rook (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL, integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)

ZDRVSY_ROOK

Purpose:

 ZDRVSY_ROOK tests the driver routines ZSYSV_ROOK.


 

Parameters:

DOTYPE

          DOTYPE is LOGICAL array, dimension (NTYPES)
          The matrix types to be used for testing.  Matrices of type j
          (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
          .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.


NN

          NN is INTEGER
          The number of values of N contained in the vector NVAL.


NVAL

          NVAL is INTEGER array, dimension (NN)
          The values of the matrix dimension N.


NRHS

          NRHS is INTEGER
          The number of right hand side vectors to be generated for
          each linear system.


THRESH

          THRESH is DOUBLE PRECISION
          The threshold value for the test ratios.  A result is
          included in the output file if RESULT >= THRESH.  To have
          every test ratio printed, use THRESH = 0.


TSTERR

          TSTERR is LOGICAL
          Flag that indicates whether error exits are to be tested.


NMAX

          NMAX is INTEGER
          The maximum value permitted for N, used in dimensioning the
          work arrays.


A

          A is COMPLEX*16 array, dimension (NMAX*NMAX)


AFAC

          AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)


AINV

          AINV is COMPLEX*16 array, dimension (NMAX*NMAX)


B

          B is COMPLEX*16 array, dimension (NMAX*NRHS)


X

          X is COMPLEX*16 array, dimension (NMAX*NRHS)


XACT

          XACT is COMPLEX*16 array, dimension (NMAX*NRHS)


WORK

          WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))


RWORK

          RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)


IWORK

          IWORK is INTEGER array, dimension (NMAX)


NOUT

          NOUT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

subroutine zebchvxx (double precision THRESH, character*3 PATH)

ZEBCHVXX Purpose:

  ZEBCHVXX will run Z**SVXX on a series of Hilbert matrices and then
  compare the error bounds returned by Z**SVXX to see if the returned
  answer indeed falls within those bounds.
  Eight test ratios will be computed.  The tests will pass if they are .LT.
  THRESH.  There are two cases that are determined by 1 / (SQRT( N ) * EPS).
  If that value is .LE. to the component wise reciprocal condition number,
  it uses the guaranteed case, other wise it uses the unguaranteed case.
  Test ratios:
     Let Xc be X_computed and Xt be X_truth.
     The norm used is the infinity norm.
     Let A be the guaranteed case and B be the unguaranteed case.
       1. Normwise guaranteed forward error bound.
       A: norm ( abs( Xc - Xt ) / norm ( Xt ) .LE. ERRBND( *, nwise_i, bnd_i ) and
          ERRBND( *, nwise_i, bnd_i ) .LE. MAX(SQRT(N),10) * EPS.
          If these conditions are met, the test ratio is set to be
          ERRBND( *, nwise_i, bnd_i ) / MAX(SQRT(N), 10).  Otherwise it is 1/EPS.
       B: For this case, CGESVXX should just return 1.  If it is less than
          one, treat it the same as in 1A.  Otherwise it fails. (Set test
          ratio to ERRBND( *, nwise_i, bnd_i ) * THRESH?)
       2. Componentwise guaranteed forward error bound.
       A: norm ( abs( Xc(j) - Xt(j) ) ) / norm (Xt(j)) .LE. ERRBND( *, cwise_i, bnd_i )
          for all j .AND. ERRBND( *, cwise_i, bnd_i ) .LE. MAX(SQRT(N), 10) * EPS.
          If these conditions are met, the test ratio is set to be
          ERRBND( *, cwise_i, bnd_i ) / MAX(SQRT(N), 10).  Otherwise it is 1/EPS.
       B: Same as normwise test ratio.
       3. Backwards error.
       A: The test ratio is set to BERR/EPS.
       B: Same test ratio.
       4. Reciprocal condition number.
       A: A condition number is computed with Xt and compared with the one
          returned from CGESVXX.  Let RCONDc be the RCOND returned by CGESVXX
          and RCONDt be the RCOND from the truth value.  Test ratio is set to
          MAX(RCONDc/RCONDt, RCONDt/RCONDc).
       B: Test ratio is set to 1 / (EPS * RCONDc).
       5. Reciprocal normwise condition number.
       A: The test ratio is set to
          MAX(ERRBND( *, nwise_i, cond_i ) / NCOND, NCOND / ERRBND( *, nwise_i, cond_i )).
       B: Test ratio is set to 1 / (EPS * ERRBND( *, nwise_i, cond_i )).
       6. Reciprocal componentwise condition number.
       A: Test ratio is set to
          MAX(ERRBND( *, cwise_i, cond_i ) / CCOND, CCOND / ERRBND( *, cwise_i, cond_i )).
       B: Test ratio is set to 1 / (EPS * ERRBND( *, cwise_i, cond_i )).
     .. Parameters ..
     NMAX is determined by the largest number in the inverse of the hilbert
     matrix.  Precision is exhausted when the largest entry in it is greater
     than 2 to the power of the number of bits in the fraction of the data
     type used plus one, which is 24 for single precision.
     NMAX should be 6 for single and 11 for double.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrab (integer NUNIT)

ZERRAB

Purpose:

 DERRAB tests the error exits for ZCGESV.


 

Parameters:

NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrac (integer NUNIT)

ZERRAC

Purpose:

 ZERRPX tests the error exits for ZCPOSV.


 

Parameters:

NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrge (character*3 PATH, integer NUNIT)

ZERRGE ZERRGEX

Purpose:

 ZERRGE tests the error exits for the COMPLEX*16 routines
 for general matrices.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Purpose:

 ZERRGE tests the error exits for the COMPLEX*16 routines
 for general matrices.
 Note that this file is used only when the XBLAS are available,
 otherwise zerrge.f defines this subroutine.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrgt (character*3 PATH, integer NUNIT)

ZERRGT

Purpose:

 ZERRGT tests the error exits for the COMPLEX*16 tridiagonal
 routines.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrhe (character*3 PATH, integer NUNIT)

ZERRHE ZERRHEX

Purpose:

 ZERRHE tests the error exits for the COMPLEX*16 routines
 for Hermitian indefinite matrices.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

Purpose:

 ZERRHE tests the error exits for the COMPLEX*16 routines
 for Hermitian indefinite matrices.
 Note that this file is used only when the XBLAS are available,
 otherwise zerrhe.f defines this subroutine.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

subroutine zerrlq (character*3 PATH, integer NUNIT)

ZERRLQ

Purpose:

 ZERRLQ tests the error exits for the COMPLEX*16 routines
 that use the LQ decomposition of a general matrix.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrls (character*3 PATH, integer NUNIT)

ZERRLS

Purpose:

 ZERRLS tests the error exits for the COMPLEX*16 least squares
 driver routines (ZGELS, CGELSS, CGELSY, CGELSD).


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

subroutine zerrpo (character*3 PATH, integer NUNIT)

ZERRPO ZERRPOX

Purpose:

 ZERRPO tests the error exits for the COMPLEX*16 routines
 for Hermitian positive definite matrices.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Purpose:

 ZERRPO tests the error exits for the COMPLEX*16 routines
 for Hermitian positive definite matrices.
 Note that this file is used only when the XBLAS are available,
 otherwise zerrpo.f defines this subroutine.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

subroutine zerrps (character*3 PATH, integer NUNIT)

ZERRPS

Purpose:

 ZERRPS tests the error exits for the COMPLEX routines
 for ZPSTRF.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrql (character*3 PATH, integer NUNIT)

ZERRQL

Purpose:

 ZERRQL tests the error exits for the COMPLEX*16 routines
 that use the QL decomposition of a general matrix.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrqp (character*3 PATH, integer NUNIT)

ZERRQP

Purpose:

 ZERRQP tests the error exits for ZGEQP3.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

subroutine zerrqr (character*3 PATH, integer NUNIT)

ZERRQR

Purpose:

 ZERRQR tests the error exits for the COMPLEX*16 routines
 that use the QR decomposition of a general matrix.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrqrt (character*3 PATH, integer NUNIT)

ZERRQRT

Purpose:

 ZERRQRT tests the error exits for the COMPLEX*16 routines
 that use the QRT decomposition of a general matrix.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrqrtp (character*3 PATH, integer NUNIT)

ZERRQRTP

Purpose:

 ZERRQRTP tests the error exits for the COMPLEX*16 routines
 that use the QRT decomposition of a triangular-pentagonal matrix.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrrfp (integer NUNIT)

ZERRRFP

Purpose:

 ZERRRFP tests the error exits for the COMPLEX*16 driver routines
 for solving linear systems of equations.
 ZDRVRFP tests the COMPLEX*16 LAPACK RFP routines:
     ZTFSM, ZTFTRI, ZHFRK, ZTFTTP, ZTFTTR, ZPFTRF, ZPFTRS, ZTPTTF,
     ZTPTTR, ZTRTTF, and ZTRTTP


 

Parameters:

NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrrq (character*3 PATH, integer NUNIT)

ZERRRQ

Purpose:

 ZERRRQ tests the error exits for the COMPLEX*16 routines
 that use the RQ decomposition of a general matrix.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrsy (character*3 PATH, integer NUNIT)

ZERRSY ZERRSYX

Purpose:

 ZERRSY tests the error exits for the COMPLEX*16 routines
 for symmetric indefinite matrices.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

Purpose:

 ZERRSY tests the error exits for the COMPLEX*16 routines
 for symmetric indefinite matrices.
 Note that this file is used only when the XBLAS are available,
 otherwise zerrsy.f defines this subroutine.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

subroutine zerrtr (character*3 PATH, integer NUNIT)

ZERRTR

Purpose:

 ZERRTR tests the error exits for the COMPLEX*16 triangular routines.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zerrtz (character*3 PATH, integer NUNIT)

ZERRTZ

Purpose:

 ZERRTZ tests the error exits for ZTZRZF.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

subroutine zerrvx (character*3 PATH, integer NUNIT)

ZERRVX ZERRVXX

Purpose:

 ZERRVX tests the error exits for the COMPLEX*16 driver routines
 for solving linear systems of equations.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

Purpose:

 ZERRVX tests the error exits for the COMPLEX*16 driver routines
 for solving linear systems of equations.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name for the routines to be tested.


NUNIT

          NUNIT is INTEGER
          The unit number for output.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

subroutine zgbt01 (integer M, integer N, integer KL, integer KU, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * ) IPIV, complex*16, dimension( * ) WORK, double precision RESID)

ZGBT01

Purpose:

 ZGBT01 reconstructs a band matrix  A  from its L*U factorization and
 computes the residual:
    norm(L*U - A) / ( N * norm(A) * EPS ),
 where EPS is the machine epsilon.
 The expression L*U - A is computed one column at a time, so A and
 AFAC are not modified.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.


KL

          KL is INTEGER
          The number of subdiagonals within the band of A.  KL >= 0.


KU

          KU is INTEGER
          The number of superdiagonals within the band of A.  KU >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original matrix A in band storage, stored in rows 1 to
          KL+KU+1.


LDA

          LDA is INTEGER.
          The leading dimension of the array A.  LDA >= max(1,KL+KU+1).


AFAC

          AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
          The factored form of the matrix A.  AFAC contains the banded
          factors L and U from the L*U factorization, as computed by
          ZGBTRF.  U is stored as an upper triangular band matrix with
          KL+KU superdiagonals in rows 1 to KL+KU+1, and the
          multipliers used during the factorization are stored in rows
          KL+KU+2 to 2*KL+KU+1.  See ZGBTRF for further details.


LDAFAC

          LDAFAC is INTEGER
          The leading dimension of the array AFAC.
          LDAFAC >= max(1,2*KL*KU+1).


IPIV

          IPIV is INTEGER array, dimension (min(M,N))
          The pivot indices from ZGBTRF.


WORK

          WORK is COMPLEX*16 array, dimension (2*KL+KU+1)


RESID

          RESID is DOUBLE PRECISION
          norm(L*U - A) / ( N * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zgbt02 (character TRANS, integer M, integer N, integer KL, integer KU, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision RESID)

ZGBT02

Purpose:

 ZGBT02 computes the residual for a solution of a banded system of
 equations  A*x = b  or  A'*x = b:
    RESID = norm( B - A*X ) / ( norm(A) * norm(X) * EPS).
 where EPS is the machine precision.


 

Parameters:

TRANS

          TRANS is CHARACTER*1
          Specifies the form of the system of equations:
          = 'N':  A *x = b
          = 'T':  A'*x = b, where A' is the transpose of A
          = 'C':  A'*x = b, where A' is the transpose of A


M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.


KL

          KL is INTEGER
          The number of subdiagonals within the band of A.  KL >= 0.


KU

          KU is INTEGER
          The number of superdiagonals within the band of A.  KU >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of B.  NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original matrix A in band storage, stored in rows 1 to
          KL+KU+1.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,KL+KU+1).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  If TRANS = 'N',
          LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the right hand side vectors for the system of
          linear equations.
          On exit, B is overwritten with the difference B - A*X.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  IF TRANS = 'N',
          LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(B - A*X) / ( norm(A) * norm(X) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zgbt05 (character TRANS, integer N, integer KL, integer KU, integer NRHS, complex*16, dimension( ldab, * ) AB, integer LDAB, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)

ZGBT05

Purpose:

 ZGBT05 tests the error bounds from iterative refinement for the
 computed solution to a system of equations op(A)*X = B, where A is a
 general band matrix of order n with kl subdiagonals and ku
 superdiagonals and op(A) = A or A**T, depending on TRANS.
 RESLTS(1) = test of the error bound
           = norm(X - XACT) / ( norm(X) * FERR )
 A large value is returned if this ratio is not less than one.
 RESLTS(2) = residual from the iterative refinement routine
           = the maximum of BERR / ( NZ*EPS + (*) ), where
             (*) = NZ*UNFL / (min_i (abs(op(A))*abs(X) +abs(b))_i )
             and NZ = max. number of nonzeros in any row of A, plus 1


 

Parameters:

TRANS

          TRANS is CHARACTER*1
          Specifies the form of the system of equations.
          = 'N':  A * X = B     (No transpose)
          = 'T':  A**T * X = B  (Transpose)
          = 'C':  A**H * X = B  (Conjugate transpose = Transpose)


N

          N is INTEGER
          The number of rows of the matrices X, B, and XACT, and the
          order of the matrix A.  N >= 0.


KL

          KL is INTEGER
          The number of subdiagonals within the band of A.  KL >= 0.


KU

          KU is INTEGER
          The number of superdiagonals within the band of A.  KU >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of the matrices X, B, and XACT.
          NRHS >= 0.


AB

          AB is COMPLEX*16 array, dimension (LDAB,N)
          The original band matrix A, stored in rows 1 to KL+KU+1.
          The j-th column of A is stored in the j-th column of the
          array AB as follows:
          AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl).


LDAB

          LDAB is INTEGER
          The leading dimension of the array AB.  LDAB >= KL+KU+1.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors.  Each vector is stored as a
          column of the matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


XACT

          XACT is COMPLEX*16 array, dimension (LDX,NRHS)
          The exact solution vectors.  Each vector is stored as a
          column of the matrix XACT.


LDXACT

          LDXACT is INTEGER
          The leading dimension of the array XACT.  LDXACT >= max(1,N).


FERR

          FERR is DOUBLE PRECISION array, dimension (NRHS)
          The estimated forward error bounds for each solution vector
          X.  If XTRUE is the true solution, FERR bounds the magnitude
          of the largest entry in (X - XTRUE) divided by the magnitude
          of the largest entry in X.


BERR

          BERR is DOUBLE PRECISION array, dimension (NRHS)
          The componentwise relative backward error of each solution
          vector (i.e., the smallest relative change in any entry of A
          or B that makes X an exact solution).


RESLTS

          RESLTS is DOUBLE PRECISION array, dimension (2)
          The maximum over the NRHS solution vectors of the ratios:
          RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
          RESLTS(2) = BERR / ( NZ*EPS + (*) )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zgelqs (integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( lwork ) WORK, integer LWORK, integer INFO)

ZGELQS

Purpose:

 Compute a minimum-norm solution
     min || A*X - B ||
 using the LQ factorization
     A = L*Q
 computed by ZGELQF.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= M >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of B.  NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          Details of the LQ factorization of the original matrix A as
          returned by ZGELQF.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= M.


TAU

          TAU is COMPLEX*16 array, dimension (M)
          Details of the orthogonal matrix Q.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the m-by-nrhs right hand side matrix B.
          On exit, the n-by-nrhs solution matrix X.


LDB

          LDB is INTEGER
          The leading dimension of the array B. LDB >= N.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of the array WORK.  LWORK must be at least NRHS,
          and should be at least NRHS*NB, where NB is the block size
          for this environment.


INFO

          INFO is INTEGER
          = 0: successful exit
          < 0: if INFO = -i, the i-th argument had an illegal value


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

logical function zgennd (integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA)

ZGENND

Purpose:

    ZGENND tests that its argument has a real, non-negative diagonal.


 

Parameters:

M

          M is INTEGER
          The number of rows in A.


N

          N is INTEGER
          The number of columns in A.


A

          A is COMPLEX*16 array, dimension (LDA, N)
          The matrix.


LDA

          LDA is INTEGER
          Leading dimension of A.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zgeqls (integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( lwork ) WORK, integer LWORK, integer INFO)

ZGEQLS

Purpose:

 Solve the least squares problem
     min || A*X - B ||
 using the QL factorization
     A = Q*L
 computed by ZGEQLF.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  M >= N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of B.  NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          Details of the QL factorization of the original matrix A as
          returned by ZGEQLF.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= M.


TAU

          TAU is COMPLEX*16 array, dimension (N)
          Details of the orthogonal matrix Q.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the m-by-nrhs right hand side matrix B.
          On exit, the n-by-nrhs solution matrix X, stored in rows
          m-n+1:m.


LDB

          LDB is INTEGER
          The leading dimension of the array B. LDB >= M.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of the array WORK.  LWORK must be at least NRHS,
          and should be at least NRHS*NB, where NB is the block size
          for this environment.


INFO

          INFO is INTEGER
          = 0: successful exit
          < 0: if INFO = -i, the i-th argument had an illegal value


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zgeqrs (integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( lwork ) WORK, integer LWORK, integer INFO)

ZGEQRS

Purpose:

 Solve the least squares problem
     min || A*X - B ||
 using the QR factorization
     A = Q*R
 computed by ZGEQRF.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  M >= N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of B.  NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          Details of the QR factorization of the original matrix A as
          returned by ZGEQRF.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= M.


TAU

          TAU is COMPLEX*16 array, dimension (N)
          Details of the orthogonal matrix Q.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the m-by-nrhs right hand side matrix B.
          On exit, the n-by-nrhs solution matrix X.


LDB

          LDB is INTEGER
          The leading dimension of the array B. LDB >= M.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of the array WORK.  LWORK must be at least NRHS,
          and should be at least NRHS*NB, where NB is the block size
          for this environment.


INFO

          INFO is INTEGER
          = 0: successful exit
          < 0: if INFO = -i, the i-th argument had an illegal value


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zgerqs (integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( lwork ) WORK, integer LWORK, integer INFO)

ZGERQS

Purpose:

 Compute a minimum-norm solution
     min || A*X - B ||
 using the RQ factorization
     A = R*Q
 computed by ZGERQF.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= M >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of B.  NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          Details of the RQ factorization of the original matrix A as
          returned by ZGERQF.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= M.


TAU

          TAU is COMPLEX*16 array, dimension (M)
          Details of the orthogonal matrix Q.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the right hand side vectors for the linear system.
          On exit, the solution vectors X.  Each solution vector
          is contained in rows 1:N of a column of B.


LDB

          LDB is INTEGER
          The leading dimension of the array B. LDB >= max(1,N).


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of the array WORK.  LWORK must be at least NRHS,
          and should be at least NRHS*NB, where NB is the block size
          for this environment.


INFO

          INFO is INTEGER
          = 0: successful exit
          < 0: if INFO = -i, the i-th argument had an illegal value


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zget01 (integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * ) IPIV, double precision, dimension( * ) RWORK, double precision RESID)

ZGET01

Purpose:

 ZGET01 reconstructs a matrix A from its L*U factorization and
 computes the residual
    norm(L*U - A) / ( N * norm(A) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original M x N matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,M).


AFAC

          AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
          The factored form of the matrix A.  AFAC contains the factors
          L and U from the L*U factorization as computed by ZGETRF.
          Overwritten with the reconstructed matrix, and then with the
          difference L*U - A.


LDAFAC

          LDAFAC is INTEGER
          The leading dimension of the array AFAC.  LDAFAC >= max(1,M).


IPIV

          IPIV is INTEGER array, dimension (N)
          The pivot indices from ZGETRF.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESID

          RESID is DOUBLE PRECISION
          norm(L*U - A) / ( N * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zget02 (character TRANS, integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)

ZGET02

Purpose:

 ZGET02 computes the residual for a solution of a system of linear
 equations  A*x = b  or  A'*x = b:
    RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

TRANS

          TRANS is CHARACTER*1
          Specifies the form of the system of equations:
          = 'N':  A *x = b
          = 'T':  A^T*x = b, where A^T is the transpose of A
          = 'C':  A^H*x = b, where A^H is the conjugate transpose of A


M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of B, the matrix of right hand sides.
          NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original M x N matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,M).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  If TRANS = 'N',
          LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the right hand side vectors for the system of
          linear equations.
          On exit, B is overwritten with the difference B - A*X.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  IF TRANS = 'N',
          LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(B - A*X) / ( norm(A) * norm(X) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

subroutine zget03 (integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldainv, * ) AINV, integer LDAINV, complex*16, dimension( ldwork, * ) WORK, integer LDWORK, double precision, dimension( * ) RWORK, double precision RCOND, double precision RESID)

ZGET03

Purpose:

 ZGET03 computes the residual for a general matrix times its inverse:
    norm( I - AINV*A ) / ( N * norm(A) * norm(AINV) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original N x N matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


AINV

          AINV is COMPLEX*16 array, dimension (LDAINV,N)
          The inverse of the matrix A.


LDAINV

          LDAINV is INTEGER
          The leading dimension of the array AINV.  LDAINV >= max(1,N).


WORK

          WORK is COMPLEX*16 array, dimension (LDWORK,N)


LDWORK

          LDWORK is INTEGER
          The leading dimension of the array WORK.  LDWORK >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RCOND

          RCOND is DOUBLE PRECISION
          The reciprocal of the condition number of A, computed as
          ( 1/norm(A) ) / norm(AINV).


RESID

          RESID is DOUBLE PRECISION
          norm(I - AINV*A) / ( N * norm(A) * norm(AINV) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zget04 (integer N, integer NRHS, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision RCOND, double precision RESID)

ZGET04

Purpose:

 ZGET04 computes the difference between a computed solution and the
 true solution to a system of linear equations.
 RESID =  ( norm(X-XACT) * RCOND ) / ( norm(XACT) * EPS ),
 where RCOND is the reciprocal of the condition number and EPS is the
 machine epsilon.


 

Parameters:

N

          N is INTEGER
          The number of rows of the matrices X and XACT.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of the matrices X and XACT.  NRHS >= 0.


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors.  Each vector is stored as a
          column of the matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


XACT

          XACT is COMPLEX*16 array, dimension (LDX,NRHS)
          The exact solution vectors.  Each vector is stored as a
          column of the matrix XACT.


LDXACT

          LDXACT is INTEGER
          The leading dimension of the array XACT.  LDXACT >= max(1,N).


RCOND

          RCOND is DOUBLE PRECISION
          The reciprocal of the condition number of the coefficient
          matrix in the system of equations.


RESID

          RESID is DOUBLE PRECISION
          The maximum over the NRHS solution vectors of
          ( norm(X-XACT) * RCOND ) / ( norm(XACT) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zget07 (character TRANS, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, logical CHKFERR, double precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)

ZGET07

Purpose:

 ZGET07 tests the error bounds from iterative refinement for the
 computed solution to a system of equations op(A)*X = B, where A is a
 general n by n matrix and op(A) = A or A**T, depending on TRANS.
 RESLTS(1) = test of the error bound
           = norm(X - XACT) / ( norm(X) * FERR )
 A large value is returned if this ratio is not less than one.
 RESLTS(2) = residual from the iterative refinement routine
           = the maximum of BERR / ( (n+1)*EPS + (*) ), where
             (*) = (n+1)*UNFL / (min_i (abs(op(A))*abs(X) +abs(b))_i )


 

Parameters:

TRANS

          TRANS is CHARACTER*1
          Specifies the form of the system of equations.
          = 'N':  A * X = B     (No transpose)
          = 'T':  A**T * X = B  (Transpose)
          = 'C':  A**H * X = B  (Conjugate transpose = Transpose)


N

          N is INTEGER
          The number of rows of the matrices X and XACT.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of the matrices X and XACT.  NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original n by n matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors.  Each vector is stored as a
          column of the matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


XACT

          XACT is COMPLEX*16 array, dimension (LDX,NRHS)
          The exact solution vectors.  Each vector is stored as a
          column of the matrix XACT.


LDXACT

          LDXACT is INTEGER
          The leading dimension of the array XACT.  LDXACT >= max(1,N).


FERR

          FERR is DOUBLE PRECISION array, dimension (NRHS)
          The estimated forward error bounds for each solution vector
          X.  If XTRUE is the true solution, FERR bounds the magnitude
          of the largest entry in (X - XTRUE) divided by the magnitude
          of the largest entry in X.


CHKFERR

          CHKFERR is LOGICAL
          Set to .TRUE. to check FERR, .FALSE. not to check FERR.
          When the test system is ill-conditioned, the "true"
          solution in XACT may be incorrect.


BERR

          BERR is DOUBLE PRECISION array, dimension (NRHS)
          The componentwise relative backward error of each solution
          vector (i.e., the smallest relative change in any entry of A
          or B that makes X an exact solution).


RESLTS

          RESLTS is DOUBLE PRECISION array, dimension (2)
          The maximum over the NRHS solution vectors of the ratios:
          RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
          RESLTS(2) = BERR / ( (n+1)*EPS + (*) )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zget08 (character TRANS, integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)

ZGET08

Purpose:

 ZGET08 computes the residual for a solution of a system of linear
 equations  A*x = b  or  A'*x = b:
    RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

TRANS

          TRANS is CHARACTER*1
          Specifies the form of the system of equations:
          = 'N':  A *x = b
          = 'T':  A^T*x = b, where A^T is the transpose of A
          = 'C':  A^H*x = b, where A^H is the conjugate transpose of A


M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of B, the matrix of right hand sides.
          NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original M x N matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,M).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  If TRANS = 'N',
          LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the right hand side vectors for the system of
          linear equations.
          On exit, B is overwritten with the difference B - A*X.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  IF TRANS = 'N',
          LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(B - A*X) / ( norm(A) * norm(X) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zgtt01 (integer N, complex*16, dimension( * ) DL, complex*16, dimension( * ) D, complex*16, dimension( * ) DU, complex*16, dimension( * ) DLF, complex*16, dimension( * ) DF, complex*16, dimension( * ) DUF, complex*16, dimension( * ) DU2, integer, dimension( * ) IPIV, complex*16, dimension( ldwork, * ) WORK, integer LDWORK, double precision, dimension( * ) RWORK, double precision RESID)

ZGTT01

Purpose:

 ZGTT01 reconstructs a tridiagonal matrix A from its LU factorization
 and computes the residual
    norm(L*U - A) / ( norm(A) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

N

          N is INTEGTER
          The order of the matrix A.  N >= 0.


DL

          DL is COMPLEX*16 array, dimension (N-1)
          The (n-1) sub-diagonal elements of A.


D

          D is COMPLEX*16 array, dimension (N)
          The diagonal elements of A.


DU

          DU is COMPLEX*16 array, dimension (N-1)
          The (n-1) super-diagonal elements of A.


DLF

          DLF is COMPLEX*16 array, dimension (N-1)
          The (n-1) multipliers that define the matrix L from the
          LU factorization of A.


DF

          DF is COMPLEX*16 array, dimension (N)
          The n diagonal elements of the upper triangular matrix U from
          the LU factorization of A.


DUF

          DUF is COMPLEX*16 array, dimension (N-1)
          The (n-1) elements of the first super-diagonal of U.


DU2

          DU2 is COMPLEX*16 array, dimension (N-2)
          The (n-2) elements of the second super-diagonal of U.


IPIV

          IPIV is INTEGER array, dimension (N)
          The pivot indices; for 1 <= i <= n, row i of the matrix was
          interchanged with row IPIV(i).  IPIV(i) will always be either
          i or i+1; IPIV(i) = i indicates a row interchange was not
          required.


WORK

          WORK is COMPLEX*16 array, dimension (LDWORK,N)


LDWORK

          LDWORK is INTEGER
          The leading dimension of the array WORK.  LDWORK >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          The scaled residual:  norm(L*U - A) / (norm(A) * EPS)


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zgtt02 (character TRANS, integer N, integer NRHS, complex*16, dimension( * ) DL, complex*16, dimension( * ) D, complex*16, dimension( * ) DU, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision RESID)

ZGTT02

Purpose:

 ZGTT02 computes the residual for the solution to a tridiagonal
 system of equations:
    RESID = norm(B - op(A)*X) / (norm(A) * norm(X) * EPS),
 where EPS is the machine epsilon.


 

Parameters:

TRANS

          TRANS is CHARACTER
          Specifies the form of the residual.
          = 'N':  B - A * X     (No transpose)
          = 'T':  B - A**T * X  (Transpose)
          = 'C':  B - A**H * X  (Conjugate transpose)


N

          N is INTEGTER
          The order of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of columns
          of the matrices B and X.  NRHS >= 0.


DL

          DL is COMPLEX*16 array, dimension (N-1)
          The (n-1) sub-diagonal elements of A.


D

          D is COMPLEX*16 array, dimension (N)
          The diagonal elements of A.


DU

          DU is COMPLEX*16 array, dimension (N-1)
          The (n-1) super-diagonal elements of A.


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the right hand side vectors for the system of
          linear equations.
          On exit, B is overwritten with the difference B - op(A)*X.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


RESID

          RESID is DOUBLE PRECISION
          norm(B - op(A)*X) / (norm(A) * norm(X) * EPS)


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zgtt05 (character TRANS, integer N, integer NRHS, complex*16, dimension( * ) DL, complex*16, dimension( * ) D, complex*16, dimension( * ) DU, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)

ZGTT05

Purpose:

 ZGTT05 tests the error bounds from iterative refinement for the
 computed solution to a system of equations A*X = B, where A is a
 general tridiagonal matrix of order n and op(A) = A or A**T,
 depending on TRANS.
 RESLTS(1) = test of the error bound
           = norm(X - XACT) / ( norm(X) * FERR )
 A large value is returned if this ratio is not less than one.
 RESLTS(2) = residual from the iterative refinement routine
           = the maximum of BERR / ( NZ*EPS + (*) ), where
             (*) = NZ*UNFL / (min_i (abs(op(A))*abs(X) +abs(b))_i )
             and NZ = max. number of nonzeros in any row of A, plus 1


 

Parameters:

TRANS

          TRANS is CHARACTER*1
          Specifies the form of the system of equations.
          = 'N':  A * X = B     (No transpose)
          = 'T':  A**T * X = B  (Transpose)
          = 'C':  A**H * X = B  (Conjugate transpose = Transpose)


N

          N is INTEGER
          The number of rows of the matrices X and XACT.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of the matrices X and XACT.  NRHS >= 0.


DL

          DL is COMPLEX*16 array, dimension (N-1)
          The (n-1) sub-diagonal elements of A.


D

          D is COMPLEX*16 array, dimension (N)
          The diagonal elements of A.


DU

          DU is COMPLEX*16 array, dimension (N-1)
          The (n-1) super-diagonal elements of A.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors.  Each vector is stored as a
          column of the matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


XACT

          XACT is COMPLEX*16 array, dimension (LDX,NRHS)
          The exact solution vectors.  Each vector is stored as a
          column of the matrix XACT.


LDXACT

          LDXACT is INTEGER
          The leading dimension of the array XACT.  LDXACT >= max(1,N).


FERR

          FERR is DOUBLE PRECISION array, dimension (NRHS)
          The estimated forward error bounds for each solution vector
          X.  If XTRUE is the true solution, FERR bounds the magnitude
          of the largest entry in (X - XTRUE) divided by the magnitude
          of the largest entry in X.


BERR

          BERR is DOUBLE PRECISION array, dimension (NRHS)
          The componentwise relative backward error of each solution
          vector (i.e., the smallest relative change in any entry of A
          or B that makes X an exact solution).


RESLTS

          RESLTS is DOUBLE PRECISION array, dimension (2)
          The maximum over the NRHS solution vectors of the ratios:
          RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
          RESLTS(2) = BERR / ( NZ*EPS + (*) )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zhet01 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * ) IPIV, complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) RWORK, double precision RESID)

ZHET01

Purpose:

 ZHET01 reconstructs a Hermitian indefinite matrix A from its
 block L*D*L' or U*D*U' factorization and computes the residual
    norm( C - A ) / ( N * norm(A) * EPS ),
 where C is the reconstructed matrix, EPS is the machine epsilon,
 L' is the conjugate transpose of L, and U' is the conjugate transpose
 of U.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original Hermitian matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N)


AFAC

          AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
          The factored form of the matrix A.  AFAC contains the block
          diagonal matrix D and the multipliers used to obtain the
          factor L or U from the block L*D*L' or U*D*U' factorization
          as computed by ZHETRF.


LDAFAC

          LDAFAC is INTEGER
          The leading dimension of the array AFAC.  LDAFAC >= max(1,N).


IPIV

          IPIV is INTEGER array, dimension (N)
          The pivot indices from ZHETRF.


C

          C is COMPLEX*16 array, dimension (LDC,N)


LDC

          LDC is INTEGER
          The leading dimension of the array C.  LDC >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
          If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

subroutine zhet01_rook (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * ) IPIV, complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) RWORK, double precision RESID)

ZHET01_ROOK

Purpose:

 ZHET01_ROOK reconstructs a complex Hermitian indefinite matrix A from its
 block L*D*L' or U*D*U' factorization and computes the residual
    norm( C - A ) / ( N * norm(A) * EPS ),
 where C is the reconstructed matrix, EPS is the machine epsilon,
 L' is the transpose of L, and U' is the transpose of U.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          complex Hermitian matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original complex Hermitian matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N)


AFAC

          AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
          The factored form of the matrix A.  AFAC contains the block
          diagonal matrix D and the multipliers used to obtain the
          factor L or U from the block L*D*L' or U*D*U' factorization
          as computed by CSYTRF_ROOK.


LDAFAC

          LDAFAC is INTEGER
          The leading dimension of the array AFAC.  LDAFAC >= max(1,N).


IPIV

          IPIV is INTEGER array, dimension (N)
          The pivot indices from CSYTRF_ROOK.


C

          C is COMPLEX*16 array, dimension (LDC,N)


LDC

          LDC is INTEGER
          The leading dimension of the array C.  LDC >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
          If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

subroutine zhpt01 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, integer, dimension( * ) IPIV, complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) RWORK, double precision RESID)

ZHPT01

Purpose:

 ZHPT01 reconstructs a Hermitian indefinite packed matrix A from its
 block L*D*L' or U*D*U' factorization and computes the residual
    norm( C - A ) / ( N * norm(A) * EPS ),
 where C is the reconstructed matrix, EPS is the machine epsilon,
 L' is the conjugate transpose of L, and U' is the conjugate transpose
 of U.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (N*(N+1)/2)
          The original Hermitian matrix A, stored as a packed
          triangular matrix.


AFAC

          AFAC is COMPLEX*16 array, dimension (N*(N+1)/2)
          The factored form of the matrix A, stored as a packed
          triangular matrix.  AFAC contains the block diagonal matrix D
          and the multipliers used to obtain the factor L or U from the
          block L*D*L' or U*D*U' factorization as computed by ZHPTRF.


IPIV

          IPIV is INTEGER array, dimension (N)
          The pivot indices from ZHPTRF.


C

          C is COMPLEX*16 array, dimension (LDC,N)


LDC

          LDC is INTEGER
          The leading dimension of the array C.  LDC >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
          If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlahilb (integer N, integer NRHS, complex*16, dimension(lda,n) A, integer LDA, complex*16, dimension(ldx, nrhs) X, integer LDX, complex*16, dimension(ldb, nrhs) B, integer LDB, double precision, dimension(n) WORK, integer INFO, character*3 PATH)

ZLAHILB

Purpose:

 ZLAHILB generates an N by N scaled Hilbert matrix in A along with
 NRHS right-hand sides in B and solutions in X such that A*X=B.
 The Hilbert matrix is scaled by M = LCM(1, 2, ..., 2*N-1) so that all
 entries are integers.  The right-hand sides are the first NRHS
 columns of M * the identity matrix, and the solutions are the
 first NRHS columns of the inverse Hilbert matrix.
 The condition number of the Hilbert matrix grows exponentially with
 its size, roughly as O(e ** (3.5*N)).  Additionally, the inverse
 Hilbert matrices beyond a relatively small dimension cannot be
 generated exactly without extra precision.  Precision is exhausted
 when the largest entry in the inverse Hilbert matrix is greater than
 2 to the power of the number of bits in the fraction of the data type
 used plus one, which is 24 for single precision.
 In single, the generated solution is exact for N <= 6 and has
 small componentwise error for 7 <= N <= 11.


 

Parameters:

N

          N is INTEGER
          The dimension of the matrix A.


NRHS

          NRHS is NRHS
          The requested number of right-hand sides.


A

          A is COMPLEX array, dimension (LDA, N)
          The generated scaled Hilbert matrix.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= N.


X

          X is COMPLEX array, dimension (LDX, NRHS)
          The generated exact solutions.  Currently, the first NRHS
          columns of the inverse Hilbert matrix.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= N.


B

          B is REAL array, dimension (LDB, NRHS)
          The generated right-hand sides.  Currently, the first NRHS
          columns of LCM(1, 2, ..., 2*N-1) * the identity matrix.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= N.


WORK

          WORK is REAL array, dimension (N)


INFO

          INFO is INTEGER
          = 0: successful exit
          = 1: N is too large; the data is still generated but may not
               be not exact.
          < 0: if INFO = -i, the i-th argument had an illegal value


PATH

          PATH is CHARACTER*3
          The LAPACK path name.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlaipd (integer N, complex*16, dimension( * ) A, integer INDA, integer VINDA)

ZLAIPD

Purpose:

 ZLAIPD sets the imaginary part of the diagonal elements of a complex
 matrix A to a large value.  This is used to test LAPACK routines for
 complex Hermitian matrices, which are not supposed to access or use
 the imaginary parts of the diagonals.


 

Parameters:

N

          N is INTEGER
         The number of diagonal elements of A.


A

          A is COMPLEX*16 array, dimension
                        (1+(N-1)*INDA+(N-2)*VINDA)
         On entry, the complex (Hermitian) matrix A.
         On exit, the imaginary parts of the diagonal elements are set
         to BIGNUM = EPS / SAFMIN, where EPS is the machine epsilon and
         SAFMIN is the safe minimum.


INDA

          INDA is INTEGER
         The increment between A(1) and the next diagonal element of A.
         Typical values are
         = LDA+1:  square matrices with leading dimension LDA
         = 2:  packed upper triangular matrix, starting at A(1,1)
         = N:  packed lower triangular matrix, starting at A(1,1)


VINDA

          VINDA is INTEGER
         The change in the diagonal increment between columns of A.
         Typical values are
         = 0:  no change, the row and column increments in A are fixed
         = 1:  packed upper triangular matrix
         = -1:  packed lower triangular matrix


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlaptm (character UPLO, integer N, integer NRHS, double precision ALPHA, double precision, dimension( * ) D, complex*16, dimension( * ) E, complex*16, dimension( ldx, * ) X, integer LDX, double precision BETA, complex*16, dimension( ldb, * ) B, integer LDB)

ZLAPTM

Purpose:

 ZLAPTM multiplies an N by NRHS matrix X by a Hermitian tridiagonal
 matrix A and stores the result in a matrix B.  The operation has the
 form
    B := alpha * A * X + beta * B
 where alpha may be either 1. or -1. and beta may be 0., 1., or -1.


 

Parameters:

UPLO

          UPLO is CHARACTER
          Specifies whether the superdiagonal or the subdiagonal of the
          tridiagonal matrix A is stored.
          = 'U':  Upper, E is the superdiagonal of A.
          = 'L':  Lower, E is the subdiagonal of A.


N

          N is INTEGER
          The order of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of columns
          of the matrices X and B.


ALPHA

          ALPHA is DOUBLE PRECISION
          The scalar alpha.  ALPHA must be 1. or -1.; otherwise,
          it is assumed to be 0.


D

          D is DOUBLE PRECISION array, dimension (N)
          The n diagonal elements of the tridiagonal matrix A.


E

          E is COMPLEX*16 array, dimension (N-1)
          The (n-1) subdiagonal or superdiagonal elements of A.


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The N by NRHS matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(N,1).


BETA

          BETA is DOUBLE PRECISION
          The scalar beta.  BETA must be 0., 1., or -1.; otherwise,
          it is assumed to be 1.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the N by NRHS matrix B.
          On exit, B is overwritten by the matrix expression
          B := alpha * A * X + beta * B.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(N,1).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlarhs (character*3 PATH, character XTYPE, character UPLO, character TRANS, integer M, integer N, integer KL, integer KU, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, integer, dimension( 4 ) ISEED, integer INFO)

ZLARHS

Purpose:

 ZLARHS chooses a set of NRHS random solution vectors and sets
 up the right hand sides for the linear system
    op( A ) * X = B,
 where op( A ) may be A, A**T (transpose of A), or A**H (conjugate
 transpose of A).


 

Parameters:

PATH

          PATH is CHARACTER*3
          The type of the complex matrix A.  PATH may be given in any
          combination of upper and lower case.  Valid paths include
             xGE:  General m x n matrix
             xGB:  General banded matrix
             xPO:  Hermitian positive definite, 2-D storage
             xPP:  Hermitian positive definite packed
             xPB:  Hermitian positive definite banded
             xHE:  Hermitian indefinite, 2-D storage
             xHP:  Hermitian indefinite packed
             xHB:  Hermitian indefinite banded
             xSY:  Symmetric indefinite, 2-D storage
             xSP:  Symmetric indefinite packed
             xSB:  Symmetric indefinite banded
             xTR:  Triangular
             xTP:  Triangular packed
             xTB:  Triangular banded
             xQR:  General m x n matrix
             xLQ:  General m x n matrix
             xQL:  General m x n matrix
             xRQ:  General m x n matrix
          where the leading character indicates the precision.


XTYPE

          XTYPE is CHARACTER*1
          Specifies how the exact solution X will be determined:
          = 'N':  New solution; generate a random X.
          = 'C':  Computed; use value of X on entry.


UPLO

          UPLO is CHARACTER*1
          Used only if A is symmetric or triangular; specifies whether
          the upper or lower triangular part of the matrix A is stored.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Used only if A is nonsymmetric; specifies the operation
          applied to the matrix A.
          = 'N':  B := A    * X
          = 'T':  B := A**T * X
          = 'C':  B := A**H * X


M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.


KL

          KL is INTEGER
          Used only if A is a band matrix; specifies the number of
          subdiagonals of A if A is a general band matrix or if A is
          symmetric or triangular and UPLO = 'L'; specifies the number
          of superdiagonals of A if A is symmetric or triangular and
          UPLO = 'U'.  0 <= KL <= M-1.


KU

          KU is INTEGER
          Used only if A is a general band matrix or if A is
          triangular.
          If PATH = xGB, specifies the number of superdiagonals of A,
          and 0 <= KU <= N-1.
          If PATH = xTR, xTP, or xTB, specifies whether or not the
          matrix has unit diagonal:
          = 1:  matrix has non-unit diagonal (default)
          = 2:  matrix has unit diagonal


NRHS

          NRHS is INTEGER
          The number of right hand side vectors in the system A*X = B.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The test matrix whose type is given by PATH.


LDA

          LDA is INTEGER
          The leading dimension of the array A.
          If PATH = xGB, LDA >= KL+KU+1.
          If PATH = xPB, xSB, xHB, or xTB, LDA >= KL+1.
          Otherwise, LDA >= max(1,M).


X

          X is or output) COMPLEX*16 array, dimension (LDX,NRHS)
          On entry, if XTYPE = 'C' (for 'Computed'), then X contains
          the exact solution to the system of linear equations.
          On exit, if XTYPE = 'N' (for 'New'), then X is initialized
          with random values.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  If TRANS = 'N',
          LDX >= max(1,N); if TRANS = 'T', LDX >= max(1,M).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vector(s) for the system of equations,
          computed from B = op(A) * X, where op(A) is determined by
          TRANS.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  If TRANS = 'N',
          LDB >= max(1,M); if TRANS = 'T', LDB >= max(1,N).


ISEED

          ISEED is INTEGER array, dimension (4)
          The seed vector for the random number generator (used in
          ZLATMS).  Modified on exit.


INFO

          INFO is INTEGER
          = 0: successful exit
          < 0: if INFO = -k, the k-th argument had an illegal value


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlatb4 (character*3 PATH, integer IMAT, integer M, integer N, character TYPE, integer KL, integer KU, double precision ANORM, integer MODE, double precision CNDNUM, character DIST)

ZLATB4

Purpose:

 ZLATB4 sets parameters for the matrix generator based on the type of
 matrix to be generated.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name.


IMAT

          IMAT is INTEGER
          An integer key describing which matrix to generate for this
          path.


M

          M is INTEGER
          The number of rows in the matrix to be generated.


N

          N is INTEGER
          The number of columns in the matrix to be generated.


TYPE

          TYPE is CHARACTER*1
          The type of the matrix to be generated:
          = 'S':  symmetric matrix
          = 'H':  Hermitian matrix
          = 'P':  Hermitian positive (semi)definite matrix
          = 'N':  nonsymmetric matrix


KL

          KL is INTEGER
          The lower band width of the matrix to be generated.


KU

          KU is INTEGER
          The upper band width of the matrix to be generated.


ANORM

          ANORM is DOUBLE PRECISION
          The desired norm of the matrix to be generated.  The diagonal
          matrix of singular values or eigenvalues is scaled by this
          value.


MODE

          MODE is INTEGER
          A key indicating how to choose the vector of eigenvalues.


CNDNUM

          CNDNUM is DOUBLE PRECISION
          The desired condition number.


DIST

          DIST is CHARACTER*1
          The type of distribution to be used by the random number
          generator.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

subroutine zlatb5 (character*3 PATH, integer IMAT, integer N, character TYPE, integer KL, integer KU, double precision ANORM, integer MODE, double precision CNDNUM, character DIST)

ZLATB5

Purpose:

 ZLATB5 sets parameters for the matrix generator based on the type
 of matrix to be generated.


 

Parameters:

PATH

          PATH is CHARACTER*3
          The LAPACK path name.


IMAT

          IMAT is INTEGER
          An integer key describing which matrix to generate for this
          path.


N

          N is INTEGER
          The number of rows and columns in the matrix to be generated.


TYPE

          TYPE is CHARACTER*1
          The type of the matrix to be generated:
          = 'S':  symmetric matrix
          = 'P':  symmetric positive (semi)definite matrix
          = 'N':  nonsymmetric matrix


KL

          KL is INTEGER
          The lower band width of the matrix to be generated.


KU

          KU is INTEGER
          The upper band width of the matrix to be generated.


ANORM

          ANORM is DOUBLE PRECISION
          The desired norm of the matrix to be generated.  The diagonal
          matrix of singular values or eigenvalues is scaled by this
          value.


MODE

          MODE is INTEGER
          A key indicating how to choose the vector of eigenvalues.


CNDNUM

          CNDNUM is DOUBLE PRECISION
          The desired condition number.


DIST

          DIST is CHARACTER*1
          The type of distribution to be used by the random number
          generator.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlatsp (character UPLO, integer N, complex*16, dimension( * ) X, integer, dimension( * ) ISEED)

ZLATSP

Purpose:

 ZLATSP generates a special test matrix for the complex symmetric
 (indefinite) factorization for packed matrices.  The pivot blocks of
 the generated matrix will be in the following order:
    2x2 pivot block, non diagonalizable
    1x1 pivot block
    2x2 pivot block, diagonalizable
    (cycle repeats)
 A row interchange is required for each non-diagonalizable 2x2 block.


 

Parameters:

UPLO

          UPLO is CHARACTER
          Specifies whether the generated matrix is to be upper or
          lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The dimension of the matrix to be generated.


X

          X is COMPLEX*16 array, dimension (N*(N+1)/2)
          The generated matrix in packed storage format.  The matrix
          consists of 3x3 and 2x2 diagonal blocks which result in the
          pivot sequence given above.  The matrix outside these
          diagonal blocks is zero.


ISEED

          ISEED is INTEGER array, dimension (4)
          On entry, the seed for the random number generator.  The last
          of the four integers must be odd.  (modified on exit)


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlatsy (character UPLO, integer N, complex*16, dimension( ldx, * ) X, integer LDX, integer, dimension( * ) ISEED)

ZLATSY

Purpose:

 ZLATSY generates a special test matrix for the complex symmetric
 (indefinite) factorization.  The pivot blocks of the generated matrix
 will be in the following order:
    2x2 pivot block, non diagonalizable
    1x1 pivot block
    2x2 pivot block, diagonalizable
    (cycle repeats)
 A row interchange is required for each non-diagonalizable 2x2 block.


 

Parameters:

UPLO

          UPLO is CHARACTER
          Specifies whether the generated matrix is to be upper or
          lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The dimension of the matrix to be generated.


X

          X is COMPLEX*16 array, dimension (LDX,N)
          The generated matrix, consisting of 3x3 and 2x2 diagonal
          blocks which result in the pivot sequence given above.
          The matrix outside of these diagonal blocks is zero.


LDX

          LDX is INTEGER
          The leading dimension of the array X.


ISEED

          ISEED is INTEGER array, dimension (4)
          On entry, the seed for the random number generator.  The last
          of the four integers must be odd.  (modified on exit)


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlattb (integer IMAT, character UPLO, character TRANS, character DIAG, integer, dimension( 4 ) ISEED, integer N, integer KD, complex*16, dimension( ldab, * ) AB, integer LDAB, complex*16, dimension( * ) B, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer INFO)

ZLATTB

Purpose:

 ZLATTB generates a triangular test matrix in 2-dimensional storage.
 IMAT and UPLO uniquely specify the properties of the test matrix,
 which is returned in the array A.


 

Parameters:

IMAT

          IMAT is INTEGER
          An integer key describing which matrix to generate for this
          path.


UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A will be upper or lower
          triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies whether the matrix or its transpose will be used.
          = 'N':  No transpose
          = 'T':  Transpose
          = 'C':  Conjugate transpose (= transpose)


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


ISEED

          ISEED is INTEGER array, dimension (4)
          The seed vector for the random number generator (used in
          ZLATMS).  Modified on exit.


N

          N is INTEGER
          The order of the matrix to be generated.


KD

          KD is INTEGER
          The number of superdiagonals or subdiagonals of the banded
          triangular matrix A.  KD >= 0.


AB

          AB is COMPLEX*16 array, dimension (LDAB,N)
          The upper or lower triangular banded matrix A, stored in the
          first KD+1 rows of AB.  Let j be a column of A, 1<=j<=n.
          If UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j.
          If UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).


LDAB

          LDAB is INTEGER
          The leading dimension of the array AB.  LDAB >= KD+1.


B

          B is COMPLEX*16 array, dimension (N)


WORK

          WORK is COMPLEX*16 array, dimension (2*N)


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


INFO

          INFO is INTEGER
          = 0:  successful exit
          < 0:  if INFO = -i, the i-th argument had an illegal value


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlattp (integer IMAT, character UPLO, character TRANS, character DIAG, integer, dimension( 4 ) ISEED, integer N, complex*16, dimension( * ) AP, complex*16, dimension( * ) B, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer INFO)

ZLATTP

Purpose:

 ZLATTP generates a triangular test matrix in packed storage.
 IMAT and UPLO uniquely specify the properties of the test matrix,
 which is returned in the array AP.


 

Parameters:

IMAT

          IMAT is INTEGER
          An integer key describing which matrix to generate for this
          path.


UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A will be upper or lower
          triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies whether the matrix or its transpose will be used.
          = 'N':  No transpose
          = 'T':  Transpose
          = 'C':  Conjugate transpose


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


ISEED

          ISEED is INTEGER array, dimension (4)
          The seed vector for the random number generator (used in
          ZLATMS).  Modified on exit.


N

          N is INTEGER
          The order of the matrix to be generated.


AP

          AP is COMPLEX*16 array, dimension (N*(N+1)/2)
          The upper or lower triangular matrix A, packed columnwise in
          a linear array.  The j-th column of A is stored in the array
          AP as follows:
          if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
          if UPLO = 'L',
             AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.


B

          B is COMPLEX*16 array, dimension (N)
          The right hand side vector, if IMAT > 10.


WORK

          WORK is COMPLEX*16 array, dimension (2*N)


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


INFO

          INFO is INTEGER
          = 0:  successful exit
          < 0:  if INFO = -i, the i-th argument had an illegal value


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlattr (integer IMAT, character UPLO, character TRANS, character DIAG, integer, dimension( 4 ) ISEED, integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) B, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer INFO)

ZLATTR

Purpose:

 ZLATTR generates a triangular test matrix in 2-dimensional storage.
 IMAT and UPLO uniquely specify the properties of the test matrix,
 which is returned in the array A.


 

Parameters:

IMAT

          IMAT is INTEGER
          An integer key describing which matrix to generate for this
          path.


UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A will be upper or lower
          triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies whether the matrix or its transpose will be used.
          = 'N':  No transpose
          = 'T':  Transpose
          = 'C':  Conjugate transpose


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


ISEED

          ISEED is INTEGER array, dimension (4)
          The seed vector for the random number generator (used in
          ZLATMS).  Modified on exit.


N

          N is INTEGER
          The order of the matrix to be generated.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The triangular matrix A.  If UPLO = 'U', the leading N x N
          upper triangular part of the array A contains the upper
          triangular matrix, and the strictly lower triangular part of
          A is not referenced.  If UPLO = 'L', the leading N x N lower
          triangular part of the array A contains the lower triangular
          matrix and the strictly upper triangular part of A is not
          referenced.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


B

          B is COMPLEX*16 array, dimension (N)
          The right hand side vector, if IMAT > 10.


WORK

          WORK is COMPLEX*16 array, dimension (2*N)


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


INFO

          INFO is INTEGER
          = 0:  successful exit
          < 0:  if INFO = -i, the i-th argument had an illegal value


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlavhe (character UPLO, character TRANS, character DIAG, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV, complex*16, dimension( ldb, * ) B, integer LDB, integer INFO)

ZLAVHE

Purpose:

 ZLAVHE performs one of the matrix-vector operations
    x := A*x  or  x := A^H*x,
 where x is an N element vector and  A is one of the factors
 from the block U*D*U' or L*D*L' factorization computed by ZHETRF.
 If TRANS = 'N', multiplies by U  or U * D  (or L  or L * D)
 If TRANS = 'C', multiplies by U' or D * U' (or L' or D * L')


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the factor stored in A is upper or lower
          triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the operation to be performed:
          = 'N':  x := A*x
          = 'C':  x := A'*x


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the diagonal blocks are unit
          matrices.  If the diagonal blocks are assumed to be unit,
          then A = U or A = L, otherwise A = U*D or A = L*D.
          = 'U':  Diagonal blocks are assumed to be unit matrices.
          = 'N':  Diagonal blocks are assumed to be non-unit matrices.


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of vectors
          x to be multiplied by A.  NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The block diagonal matrix D and the multipliers used to
          obtain the factor U or L as computed by ZHETRF.
          Stored as a 2-D triangular matrix.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


IPIV

          IPIV is INTEGER array, dimension (N)
          Details of the interchanges and the block structure of D,
          as determined by ZHETRF.
          If UPLO = 'U':
               If IPIV(k) > 0, then rows and columns k and IPIV(k)
               were interchanged and D(k,k) is a 1-by-1 diagonal block.
               (If IPIV( k ) = k, no interchange was done).
               If IPIV(k) = IPIV(k-1) < 0, then rows and
               columns k-1 and -IPIV(k) were interchanged,
               D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
          If UPLO = 'L':
               If IPIV(k) > 0, then rows and columns k and IPIV(k)
               were interchanged and D(k,k) is a 1-by-1 diagonal block.
               (If IPIV( k ) = k, no interchange was done).
               If IPIV(k) = IPIV(k+1) < 0, then rows and
               columns k+1 and -IPIV(k) were interchanged,
               D(k:k+1,k:k+1) is a 2-by-2 diagonal block.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, B contains NRHS vectors of length N.
          On exit, B is overwritten with the product A * B.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


INFO

          INFO is INTEGER
          = 0: successful exit
          < 0: if INFO = -k, the k-th argument had an illegal value


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

subroutine zlavhe_rook (character UPLO, character TRANS, character DIAG, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV, complex*16, dimension( ldb, * ) B, integer LDB, integer INFO)

ZLAVHE_ROOK

Purpose:

ZLAVHE_ROOK performs one of the matrix-vector operations x := A*x or x := A^H*x, where x is an N element vector and A is one of the factors from the block U*D*U' or L*D*L' factorization computed by ZHETRF_ROOK.

If TRANS = 'N', multiplies by U or U * D (or L or L * D) If TRANS = 'C', multiplies by U' or D * U' (or L' or D * L')

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the factor stored in A is upper or lower
          triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the operation to be performed:
          = 'N':  x := A*x
          = 'C':   x := A^H*x


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the diagonal blocks are unit
          matrices.  If the diagonal blocks are assumed to be unit,
          then A = U or A = L, otherwise A = U*D or A = L*D.
          = 'U':  Diagonal blocks are assumed to be unit matrices.
          = 'N':  Diagonal blocks are assumed to be non-unit matrices.


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of vectors
          x to be multiplied by A.  NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The block diagonal matrix D and the multipliers used to
          obtain the factor U or L as computed by ZHETRF_ROOK.
          Stored as a 2-D triangular matrix.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


IPIV

          IPIV is INTEGER array, dimension (N)
          Details of the interchanges and the block structure of D,
          as determined by ZHETRF_ROOK.
          If UPLO = 'U':
             Only the last KB elements of IPIV are set.
             If IPIV(k) > 0, then rows and columns k and IPIV(k) were
             interchanged and D(k,k) is a 1-by-1 diagonal block.
             If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and
             columns k and -IPIV(k) were interchanged and rows and
             columns k-1 and -IPIV(k-1) were inerchaged,
             D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
          If UPLO = 'L':
             Only the first KB elements of IPIV are set.
             If IPIV(k) > 0, then rows and columns k and IPIV(k)
             were interchanged and D(k,k) is a 1-by-1 diagonal block.
             If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and
             columns k and -IPIV(k) were interchanged and rows and
             columns k+1 and -IPIV(k+1) were inerchaged,
             D(k:k+1,k:k+1) is a 2-by-2 diagonal block.


B

          B is COMPLEX array, dimension (LDB,NRHS)
          On entry, B contains NRHS vectors of length N.
          On exit, B is overwritten with the product A * B.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


INFO

          INFO is INTEGER
          = 0: successful exit
          < 0: if INFO = -k, the k-th argument had an illegal value


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

subroutine zlavhp (character UPLO, character TRANS, character DIAG, integer N, integer NRHS, complex*16, dimension( * ) A, integer, dimension( * ) IPIV, complex*16, dimension( ldb, * ) B, integer LDB, integer INFO)

ZLAVHP

Purpose:

    ZLAVHP  performs one of the matrix-vector operations
       x := A*x  or  x := A^H*x,
    where x is an N element vector and  A is one of the factors
    from the symmetric factorization computed by ZHPTRF.
    ZHPTRF produces a factorization of the form
         U * D * U^H     or     L * D * L^H,
    where U (or L) is a product of permutation and unit upper (lower)
    triangular matrices, U^H (or L^H) is the conjugate transpose of
    U (or L), and D is Hermitian and block diagonal with 1 x 1 and
    2 x 2 diagonal blocks.  The multipliers for the transformations
    and the upper or lower triangular parts of the diagonal blocks
    are stored columnwise in packed format in the linear array A.
    If TRANS = 'N' or 'n', ZLAVHP multiplies either by U or U * D
    (or L or L * D).
    If TRANS = 'C' or 'c', ZLAVHP multiplies either by U^H or D * U^H
    (or L^H or D * L^H ).


 

  UPLO   - CHARACTER*1
           On entry, UPLO specifies whether the triangular matrix
           stored in A is upper or lower triangular.
              UPLO = 'U' or 'u'   The matrix is upper triangular.
              UPLO = 'L' or 'l'   The matrix is lower triangular.
           Unchanged on exit.
  TRANS  - CHARACTER*1
           On entry, TRANS specifies the operation to be performed as
           follows:
              TRANS = 'N' or 'n'   x := A*x.
              TRANS = 'C' or 'c'   x := A^H*x.
           Unchanged on exit.
  DIAG   - CHARACTER*1
           On entry, DIAG specifies whether the diagonal blocks are
           assumed to be unit matrices, as follows:
              DIAG = 'U' or 'u'   Diagonal blocks are unit matrices.
              DIAG = 'N' or 'n'   Diagonal blocks are non-unit.
           Unchanged on exit.
  N      - INTEGER
           On entry, N specifies the order of the matrix A.
           N must be at least zero.
           Unchanged on exit.
  NRHS   - INTEGER
           On entry, NRHS specifies the number of right hand sides,
           i.e., the number of vectors x to be multiplied by A.
           NRHS must be at least zero.
           Unchanged on exit.
  A      - COMPLEX*16 array, dimension( N*(N+1)/2 )
           On entry, A contains a block diagonal matrix and the
           multipliers of the transformations used to obtain it,
           stored as a packed triangular matrix.
           Unchanged on exit.
  IPIV   - INTEGER array, dimension( N )
           On entry, IPIV contains the vector of pivot indices as
           determined by ZSPTRF or ZHPTRF.
           If IPIV( K ) = K, no interchange was done.
           If IPIV( K ) <> K but IPIV( K ) > 0, then row K was inter-
           changed with row IPIV( K ) and a 1 x 1 pivot block was used.
           If IPIV( K ) < 0 and UPLO = 'U', then row K-1 was exchanged
           with row | IPIV( K ) | and a 2 x 2 pivot block was used.
           If IPIV( K ) < 0 and UPLO = 'L', then row K+1 was exchanged
           with row | IPIV( K ) | and a 2 x 2 pivot block was used.
  B      - COMPLEX*16 array, dimension( LDB, NRHS )
           On entry, B contains NRHS vectors of length N.
           On exit, B is overwritten with the product A * B.
  LDB    - INTEGER
           On entry, LDB contains the leading dimension of B as
           declared in the calling program.  LDB must be at least
           max( 1, N ).
           Unchanged on exit.
  INFO   - INTEGER
           INFO is the error flag.
           On exit, a value of 0 indicates a successful exit.
           A negative value, say -K, indicates that the K-th argument
           has an illegal value.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlavsp (character UPLO, character TRANS, character DIAG, integer N, integer NRHS, complex*16, dimension( * ) A, integer, dimension( * ) IPIV, complex*16, dimension( ldb, * ) B, integer LDB, integer INFO)

ZLAVSP

Purpose:

    ZLAVSP  performs one of the matrix-vector operations
       x := A*x  or  x := A^T*x,
    where x is an N element vector and  A is one of the factors
    from the symmetric factorization computed by ZSPTRF.
    ZSPTRF produces a factorization of the form
         U * D * U^T     or     L * D * L^T,
    where U (or L) is a product of permutation and unit upper (lower)
    triangular matrices, U^T (or L^T) is the transpose of
    U (or L), and D is symmetric and block diagonal with 1 x 1 and
    2 x 2 diagonal blocks.  The multipliers for the transformations
    and the upper or lower triangular parts of the diagonal blocks
    are stored columnwise in packed format in the linear array A.
    If TRANS = 'N' or 'n', ZLAVSP multiplies either by U or U * D
    (or L or L * D).
    If TRANS = 'C' or 'c', ZLAVSP multiplies either by U^T or D * U^T
    (or L^T or D * L^T ).


 

  UPLO   - CHARACTER*1
           On entry, UPLO specifies whether the triangular matrix
           stored in A is upper or lower triangular.
              UPLO = 'U' or 'u'   The matrix is upper triangular.
              UPLO = 'L' or 'l'   The matrix is lower triangular.
           Unchanged on exit.
  TRANS  - CHARACTER*1
           On entry, TRANS specifies the operation to be performed as
           follows:
              TRANS = 'N' or 'n'   x := A*x.
              TRANS = 'T' or 't'   x := A^T*x.
           Unchanged on exit.
  DIAG   - CHARACTER*1
           On entry, DIAG specifies whether the diagonal blocks are
           assumed to be unit matrices, as follows:
              DIAG = 'U' or 'u'   Diagonal blocks are unit matrices.
              DIAG = 'N' or 'n'   Diagonal blocks are non-unit.
           Unchanged on exit.
  N      - INTEGER
           On entry, N specifies the order of the matrix A.
           N must be at least zero.
           Unchanged on exit.
  NRHS   - INTEGER
           On entry, NRHS specifies the number of right hand sides,
           i.e., the number of vectors x to be multiplied by A.
           NRHS must be at least zero.
           Unchanged on exit.
  A      - COMPLEX*16 array, dimension( N*(N+1)/2 )
           On entry, A contains a block diagonal matrix and the
           multipliers of the transformations used to obtain it,
           stored as a packed triangular matrix.
           Unchanged on exit.
  IPIV   - INTEGER array, dimension( N )
           On entry, IPIV contains the vector of pivot indices as
           determined by ZSPTRF.
           If IPIV( K ) = K, no interchange was done.
           If IPIV( K ) <> K but IPIV( K ) > 0, then row K was inter-
           changed with row IPIV( K ) and a 1 x 1 pivot block was used.
           If IPIV( K ) < 0 and UPLO = 'U', then row K-1 was exchanged
           with row | IPIV( K ) | and a 2 x 2 pivot block was used.
           If IPIV( K ) < 0 and UPLO = 'L', then row K+1 was exchanged
           with row | IPIV( K ) | and a 2 x 2 pivot block was used.
  B      - COMPLEX*16 array, dimension( LDB, NRHS )
           On entry, B contains NRHS vectors of length N.
           On exit, B is overwritten with the product A * B.
  LDB    - INTEGER
           On entry, LDB contains the leading dimension of B as
           declared in the calling program.  LDB must be at least
           max( 1, N ).
           Unchanged on exit.
  INFO   - INTEGER
           INFO is the error flag.
           On exit, a value of 0 indicates a successful exit.
           A negative value, say -K, indicates that the K-th argument
           has an illegal value.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlavsy (character UPLO, character TRANS, character DIAG, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV, complex*16, dimension( ldb, * ) B, integer LDB, integer INFO)

ZLAVSY

Purpose:

 ZLAVSY performs one of the matrix-vector operations
    x := A*x  or  x := A'*x,
 where x is an N element vector and  A is one of the factors
 from the block U*D*U' or L*D*L' factorization computed by ZSYTRF.
 If TRANS = 'N', multiplies by U  or U * D  (or L  or L * D)
 If TRANS = 'T', multiplies by U' or D * U' (or L' or D * L')


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the factor stored in A is upper or lower
          triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the operation to be performed:
          = 'N':  x := A*x
          = 'T':  x := A'*x


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the diagonal blocks are unit
          matrices.  If the diagonal blocks are assumed to be unit,
          then A = U or A = L, otherwise A = U*D or A = L*D.
          = 'U':  Diagonal blocks are assumed to be unit matrices.
          = 'N':  Diagonal blocks are assumed to be non-unit matrices.


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of vectors
          x to be multiplied by A.  NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The block diagonal matrix D and the multipliers used to
          obtain the factor U or L as computed by ZSYTRF.
          Stored as a 2-D triangular matrix.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


IPIV

          IPIV is INTEGER array, dimension (N)
          Details of the interchanges and the block structure of D,
          as determined by ZSYTRF.
          If UPLO = 'U':
               If IPIV(k) > 0, then rows and columns k and IPIV(k)
               were interchanged and D(k,k) is a 1-by-1 diagonal block.
               (If IPIV( k ) = k, no interchange was done).
               If IPIV(k) = IPIV(k-1) < 0, then rows and
               columns k-1 and -IPIV(k) were interchanged,
               D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
          If UPLO = 'L':
               If IPIV(k) > 0, then rows and columns k and IPIV(k)
               were interchanged and D(k,k) is a 1-by-1 diagonal block.
               (If IPIV( k ) = k, no interchange was done).
               If IPIV(k) = IPIV(k+1) < 0, then rows and
               columns k+1 and -IPIV(k) were interchanged,
               D(k:k+1,k:k+1) is a 2-by-2 diagonal block.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, B contains NRHS vectors of length N.
          On exit, B is overwritten with the product A * B.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


INFO

          INFO is INTEGER
          = 0: successful exit
          < 0: if INFO = -k, the k-th argument had an illegal value


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

subroutine zlavsy_rook (character UPLO, character TRANS, character DIAG, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV, complex*16, dimension( ldb, * ) B, integer LDB, integer INFO)

ZLAVSY_ROOK

Purpose:

 ZLAVSY_ROOK performs one of the matrix-vector operations
    x := A*x  or  x := A'*x,
 where x is an N element vector and  A is one of the factors
 from the block U*D*U' or L*D*L' factorization computed by ZSYTRF_ROOK.
 If TRANS = 'N', multiplies by U  or U * D  (or L  or L * D)
 If TRANS = 'T', multiplies by U' or D * U' (or L' or D * L')


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the factor stored in A is upper or lower
          triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the operation to be performed:
          = 'N':  x := A*x
          = 'T':  x := A'*x


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the diagonal blocks are unit
          matrices.  If the diagonal blocks are assumed to be unit,
          then A = U or A = L, otherwise A = U*D or A = L*D.
          = 'U':  Diagonal blocks are assumed to be unit matrices.
          = 'N':  Diagonal blocks are assumed to be non-unit matrices.


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of vectors
          x to be multiplied by A.  NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The block diagonal matrix D and the multipliers used to
          obtain the factor U or L as computed by ZSYTRF_ROOK.
          Stored as a 2-D triangular matrix.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


IPIV

          IPIV is INTEGER array, dimension (N)
          Details of the interchanges and the block structure of D,
          as determined by ZSYTRF_ROOK.
          If UPLO = 'U':
               If IPIV(k) > 0, then rows and columns k and IPIV(k)
               were interchanged and D(k,k) is a 1-by-1 diagonal block.
               (If IPIV( k ) = k, no interchange was done).
               If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and
               columns k and -IPIV(k) were interchanged and rows and
               columns k-1 and -IPIV(k-1) were inerchaged,
               D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
          If UPLO = 'L':
               If IPIV(k) > 0, then rows and columns k and IPIV(k)
               were interchanged and D(k,k) is a 1-by-1 diagonal block.
               (If IPIV( k ) = k, no interchange was done).
               If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and
               columns k and -IPIV(k) were interchanged and rows and
               columns k+1 and -IPIV(k+1) were inerchaged,
               D(k:k+1,k:k+1) is a 2-by-2 diagonal block.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, B contains NRHS vectors of length N.
          On exit, B is overwritten with the product A * B.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


INFO

          INFO is INTEGER
          = 0: successful exit
          < 0: if INFO = -k, the k-th argument had an illegal value


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

subroutine zlqt01 (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * ) L, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT)

ZLQT01

Purpose:

 ZLQT01 tests ZGELQF, which computes the LQ factorization of an m-by-n
 matrix A, and partially tests ZUNGLQ which forms the n-by-n
 orthogonal matrix Q.
 ZLQT01 compares L with A*Q', and checks that Q is orthogonal.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The m-by-n matrix A.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          Details of the LQ factorization of A, as returned by ZGELQF.
          See ZGELQF for further details.


Q

          Q is COMPLEX*16 array, dimension (LDA,N)
          The n-by-n orthogonal matrix Q.


L

          L is COMPLEX*16 array, dimension (LDA,max(M,N))


LDA

          LDA is INTEGER
          The leading dimension of the arrays A, AF, Q and L.
          LDA >= max(M,N).


TAU

          TAU is COMPLEX*16 array, dimension (min(M,N))
          The scalar factors of the elementary reflectors, as returned
          by ZGELQF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The dimension of the array WORK.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (max(M,N))


RESULT

          RESULT is DOUBLE PRECISION array, dimension (2)
          The test ratios:
          RESULT(1) = norm( L - A*Q' ) / ( N * norm(A) * EPS )
          RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlqt02 (integer M, integer N, integer K, complex*16, dimension( lda, * ) A, complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * ) L, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT)

ZLQT02

Purpose:

 ZLQT02 tests ZUNGLQ, which generates an m-by-n matrix Q with
 orthonornmal rows that is defined as the product of k elementary
 reflectors.
 Given the LQ factorization of an m-by-n matrix A, ZLQT02 generates
 the orthogonal matrix Q defined by the factorization of the first k
 rows of A; it compares L(1:k,1:m) with A(1:k,1:n)*Q(1:m,1:n)', and
 checks that the rows of Q are orthonormal.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix Q to be generated.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix Q to be generated.
          N >= M >= 0.


K

          K is INTEGER
          The number of elementary reflectors whose product defines the
          matrix Q. M >= K >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The m-by-n matrix A which was factorized by ZLQT01.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          Details of the LQ factorization of A, as returned by ZGELQF.
          See ZGELQF for further details.


Q

          Q is COMPLEX*16 array, dimension (LDA,N)


L

          L is COMPLEX*16 array, dimension (LDA,M)


LDA

          LDA is INTEGER
          The leading dimension of the arrays A, AF, Q and L. LDA >= N.


TAU

          TAU is COMPLEX*16 array, dimension (M)
          The scalar factors of the elementary reflectors corresponding
          to the LQ factorization in AF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The dimension of the array WORK.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESULT

          RESULT is DOUBLE PRECISION array, dimension (2)
          The test ratios:
          RESULT(1) = norm( L - A*Q' ) / ( N * norm(A) * EPS )
          RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zlqt03 (integer M, integer N, integer K, complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) C, complex*16, dimension( lda, * ) CC, complex*16, dimension( lda, * ) Q, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT)

ZLQT03

Purpose:

 ZLQT03 tests ZUNMLQ, which computes Q*C, Q'*C, C*Q or C*Q'.
 ZLQT03 compares the results of a call to ZUNMLQ with the results of
 forming Q explicitly by a call to ZUNGLQ and then performing matrix
 multiplication by a call to ZGEMM.


 

Parameters:

M

          M is INTEGER
          The number of rows or columns of the matrix C; C is n-by-m if
          Q is applied from the left, or m-by-n if Q is applied from
          the right.  M >= 0.


N

          N is INTEGER
          The order of the orthogonal matrix Q.  N >= 0.


K

          K is INTEGER
          The number of elementary reflectors whose product defines the
          orthogonal matrix Q.  N >= K >= 0.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          Details of the LQ factorization of an m-by-n matrix, as
          returned by ZGELQF. See CGELQF for further details.


C

          C is COMPLEX*16 array, dimension (LDA,N)


CC

          CC is COMPLEX*16 array, dimension (LDA,N)


Q

          Q is COMPLEX*16 array, dimension (LDA,N)


LDA

          LDA is INTEGER
          The leading dimension of the arrays AF, C, CC, and Q.


TAU

          TAU is COMPLEX*16 array, dimension (min(M,N))
          The scalar factors of the elementary reflectors corresponding
          to the LQ factorization in AF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of WORK.  LWORK must be at least M, and should be
          M*NB, where NB is the blocksize for this environment.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESULT

          RESULT is DOUBLE PRECISION array, dimension (4)
          The test ratios compare two techniques for multiplying a
          random matrix C by an n-by-n orthogonal matrix Q.
          RESULT(1) = norm( Q*C - Q*C )  / ( N * norm(C) * EPS )
          RESULT(2) = norm( C*Q - C*Q )  / ( N * norm(C) * EPS )
          RESULT(3) = norm( Q'*C - Q'*C )/ ( N * norm(C) * EPS )
          RESULT(4) = norm( C*Q' - C*Q' )/ ( N * norm(C) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zpbt01 (character UPLO, integer N, integer KD, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, double precision, dimension( * ) RWORK, double precision RESID)

ZPBT01

Purpose:

 ZPBT01 reconstructs a Hermitian positive definite band matrix A from
 its L*L' or U'*U factorization and computes the residual
    norm( L*L' - A ) / ( N * norm(A) * EPS ) or
    norm( U'*U - A ) / ( N * norm(A) * EPS ),
 where EPS is the machine epsilon, L' is the conjugate transpose of
 L, and U' is the conjugate transpose of U.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


KD

          KD is INTEGER
          The number of super-diagonals of the matrix A if UPLO = 'U',
          or the number of sub-diagonals if UPLO = 'L'.  KD >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original Hermitian band matrix A.  If UPLO = 'U', the
          upper triangular part of A is stored as a band matrix; if
          UPLO = 'L', the lower triangular part of A is stored.  The
          columns of the appropriate triangle are stored in the columns
          of A and the diagonals of the triangle are stored in the rows
          of A.  See ZPBTRF for further details.


LDA

          LDA is INTEGER.
          The leading dimension of the array A.  LDA >= max(1,KD+1).


AFAC

          AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
          The factored form of the matrix A.  AFAC contains the factor
          L or U from the L*L' or U'*U factorization in band storage
          format, as computed by ZPBTRF.


LDAFAC

          LDAFAC is INTEGER
          The leading dimension of the array AFAC.
          LDAFAC >= max(1,KD+1).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS )
          If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zpbt02 (character UPLO, integer N, integer KD, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)

ZPBT02

Purpose:

 ZPBT02 computes the residual for a solution of a Hermitian banded
 system of equations  A*x = b:
    RESID = norm( B - A*X ) / ( norm(A) * norm(X) * EPS)
 where EPS is the machine precision.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


KD

          KD is INTEGER
          The number of super-diagonals of the matrix A if UPLO = 'U',
          or the number of sub-diagonals if UPLO = 'L'.  KD >= 0.


NRHS

          NRHS is INTEGER
          The number of right hand sides. NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original Hermitian band matrix A.  If UPLO = 'U', the
          upper triangular part of A is stored as a band matrix; if
          UPLO = 'L', the lower triangular part of A is stored.  The
          columns of the appropriate triangle are stored in the columns
          of A and the diagonals of the triangle are stored in the rows
          of A.  See ZPBTRF for further details.


LDA

          LDA is INTEGER.
          The leading dimension of the array A.  LDA >= max(1,KD+1).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.   LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the right hand side vectors for the system of
          linear equations.
          On exit, B is overwritten with the difference B - A*X.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(B - A*X) / ( norm(A) * norm(X) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zpbt05 (character UPLO, integer N, integer KD, integer NRHS, complex*16, dimension( ldab, * ) AB, integer LDAB, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)

ZPBT05

Purpose:

 ZPBT05 tests the error bounds from iterative refinement for the
 computed solution to a system of equations A*X = B, where A is a
 Hermitian band matrix.
 RESLTS(1) = test of the error bound
           = norm(X - XACT) / ( norm(X) * FERR )
 A large value is returned if this ratio is not less than one.
 RESLTS(2) = residual from the iterative refinement routine
           = the maximum of BERR / ( NZ*EPS + (*) ), where
             (*) = NZ*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
             and NZ = max. number of nonzeros in any row of A, plus 1


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows of the matrices X, B, and XACT, and the
          order of the matrix A.  N >= 0.


KD

          KD is INTEGER
          The number of super-diagonals of the matrix A if UPLO = 'U',
          or the number of sub-diagonals if UPLO = 'L'.  KD >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of the matrices X, B, and XACT.
          NRHS >= 0.


AB

          AB is COMPLEX*16 array, dimension (LDAB,N)
          The upper or lower triangle of the Hermitian band matrix A,
          stored in the first KD+1 rows of the array.  The j-th column
          of A is stored in the j-th column of the array AB as follows:
          if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
          if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).


LDAB

          LDAB is INTEGER
          The leading dimension of the array AB.  LDAB >= KD+1.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors.  Each vector is stored as a
          column of the matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


XACT

          XACT is COMPLEX*16 array, dimension (LDX,NRHS)
          The exact solution vectors.  Each vector is stored as a
          column of the matrix XACT.


LDXACT

          LDXACT is INTEGER
          The leading dimension of the array XACT.  LDXACT >= max(1,N).


FERR

          FERR is DOUBLE PRECISION array, dimension (NRHS)
          The estimated forward error bounds for each solution vector
          X.  If XTRUE is the true solution, FERR bounds the magnitude
          of the largest entry in (X - XTRUE) divided by the magnitude
          of the largest entry in X.


BERR

          BERR is DOUBLE PRECISION array, dimension (NRHS)
          The componentwise relative backward error of each solution
          vector (i.e., the smallest relative change in any entry of A
          or B that makes X an exact solution).


RESLTS

          RESLTS is DOUBLE PRECISION array, dimension (2)
          The maximum over the NRHS solution vectors of the ratios:
          RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
          RESLTS(2) = BERR / ( NZ*EPS + (*) )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zpot01 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, double precision, dimension( * ) RWORK, double precision RESID)

ZPOT01

Purpose:

 ZPOT01 reconstructs a Hermitian positive definite matrix  A  from
 its L*L' or U'*U factorization and computes the residual
    norm( L*L' - A ) / ( N * norm(A) * EPS ) or
    norm( U'*U - A ) / ( N * norm(A) * EPS ),
 where EPS is the machine epsilon, L' is the conjugate transpose of L,
 and U' is the conjugate transpose of U.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original Hermitian matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N)


AFAC

          AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
          On entry, the factor L or U from the L*L' or U'*U
          factorization of A.
          Overwritten with the reconstructed matrix, and then with the
          difference L*L' - A (or U'*U - A).


LDAFAC

          LDAFAC is INTEGER
          The leading dimension of the array AFAC.  LDAFAC >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS )
          If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zpot02 (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)

ZPOT02

Purpose:

 ZPOT02 computes the residual for the solution of a Hermitian system
 of linear equations  A*x = b:
    RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of B, the matrix of right hand sides.
          NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original Hermitian matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N)


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.   LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the right hand side vectors for the system of
          linear equations.
          On exit, B is overwritten with the difference B - A*X.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(B - A*X) / ( norm(A) * norm(X) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zpot03 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldainv, * ) AINV, integer LDAINV, complex*16, dimension( ldwork, * ) WORK, integer LDWORK, double precision, dimension( * ) RWORK, double precision RCOND, double precision RESID)

ZPOT03

Purpose:

 ZPOT03 computes the residual for a Hermitian matrix times its
 inverse:
    norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original Hermitian matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N)


AINV

          AINV is COMPLEX*16 array, dimension (LDAINV,N)
          On entry, the inverse of the matrix A, stored as a Hermitian
          matrix in the same format as A.
          In this version, AINV is expanded into a full matrix and
          multiplied by A, so the opposing triangle of AINV will be
          changed; i.e., if the upper triangular part of AINV is
          stored, the lower triangular part will be used as work space.


LDAINV

          LDAINV is INTEGER
          The leading dimension of the array AINV.  LDAINV >= max(1,N).


WORK

          WORK is COMPLEX*16 array, dimension (LDWORK,N)


LDWORK

          LDWORK is INTEGER
          The leading dimension of the array WORK.  LDWORK >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RCOND

          RCOND is DOUBLE PRECISION
          The reciprocal of the condition number of A, computed as
          ( 1/norm(A) ) / norm(AINV).


RESID

          RESID is DOUBLE PRECISION
          norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zpot05 (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)

ZPOT05

Purpose:

 ZPOT05 tests the error bounds from iterative refinement for the
 computed solution to a system of equations A*X = B, where A is a
 Hermitian n by n matrix.
 RESLTS(1) = test of the error bound
           = norm(X - XACT) / ( norm(X) * FERR )
 A large value is returned if this ratio is not less than one.
 RESLTS(2) = residual from the iterative refinement routine
           = the maximum of BERR / ( (n+1)*EPS + (*) ), where
             (*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows of the matrices X, B, and XACT, and the
          order of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of the matrices X, B, and XACT.
          NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The Hermitian matrix A.  If UPLO = 'U', the leading n by n
          upper triangular part of A contains the upper triangular part
          of the matrix A, and the strictly lower triangular part of A
          is not referenced.  If UPLO = 'L', the leading n by n lower
          triangular part of A contains the lower triangular part of
          the matrix A, and the strictly upper triangular part of A is
          not referenced.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors.  Each vector is stored as a
          column of the matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


XACT

          XACT is COMPLEX*16 array, dimension (LDX,NRHS)
          The exact solution vectors.  Each vector is stored as a
          column of the matrix XACT.


LDXACT

          LDXACT is INTEGER
          The leading dimension of the array XACT.  LDXACT >= max(1,N).


FERR

          FERR is DOUBLE PRECISION array, dimension (NRHS)
          The estimated forward error bounds for each solution vector
          X.  If XTRUE is the true solution, FERR bounds the magnitude
          of the largest entry in (X - XTRUE) divided by the magnitude
          of the largest entry in X.


BERR

          BERR is DOUBLE PRECISION array, dimension (NRHS)
          The componentwise relative backward error of each solution
          vector (i.e., the smallest relative change in any entry of A
          or B that makes X an exact solution).


RESLTS

          RESLTS is DOUBLE PRECISION array, dimension (2)
          The maximum over the NRHS solution vectors of the ratios:
          RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
          RESLTS(2) = BERR / ( (n+1)*EPS + (*) )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zpot06 (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)

ZPOT06

Purpose:

 ZPOT06 computes the residual for a solution of a system of linear
 equations  A*x = b :
    RESID = norm(B - A*X,inf) / ( norm(A,inf) * norm(X,inf) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          symmetric matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of B, the matrix of right hand sides.
          NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original M x N matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  If TRANS = 'N',
          LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the right hand side vectors for the system of
          linear equations.
          On exit, B is overwritten with the difference B - A*X.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  IF TRANS = 'N',
          LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(B - A*X) / ( norm(A) * norm(X) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zppt01 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, double precision, dimension( * ) RWORK, double precision RESID)

ZPPT01

Purpose:

 ZPPT01 reconstructs a Hermitian positive definite packed matrix A
 from its L*L' or U'*U factorization and computes the residual
    norm( L*L' - A ) / ( N * norm(A) * EPS ) or
    norm( U'*U - A ) / ( N * norm(A) * EPS ),
 where EPS is the machine epsilon, L' is the conjugate transpose of
 L, and U' is the conjugate transpose of U.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (N*(N+1)/2)
          The original Hermitian matrix A, stored as a packed
          triangular matrix.


AFAC

          AFAC is COMPLEX*16 array, dimension (N*(N+1)/2)
          On entry, the factor L or U from the L*L' or U'*U
          factorization of A, stored as a packed triangular matrix.
          Overwritten with the reconstructed matrix, and then with the
          difference L*L' - A (or U'*U - A).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS )
          If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zppt02 (character UPLO, integer N, integer NRHS, complex*16, dimension( * ) A, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)

ZPPT02

Purpose:

 ZPPT02 computes the residual in the solution of a Hermitian system
 of linear equations  A*x = b  when packed storage is used for the
 coefficient matrix.  The ratio computed is
    RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS),
 where EPS is the machine precision.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of B, the matrix of right hand sides.
          NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (N*(N+1)/2)
          The original Hermitian matrix A, stored as a packed
          triangular matrix.


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.   LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the right hand side vectors for the system of
          linear equations.
          On exit, B is overwritten with the difference B - A*X.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(B - A*X) / ( norm(A) * norm(X) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zppt03 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16, dimension( * ) AINV, complex*16, dimension( ldwork, * ) WORK, integer LDWORK, double precision, dimension( * ) RWORK, double precision RCOND, double precision RESID)

ZPPT03

Purpose:

 ZPPT03 computes the residual for a Hermitian packed matrix times its
 inverse:
    norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (N*(N+1)/2)
          The original Hermitian matrix A, stored as a packed
          triangular matrix.


AINV

          AINV is COMPLEX*16 array, dimension (N*(N+1)/2)
          The (Hermitian) inverse of the matrix A, stored as a packed
          triangular matrix.


WORK

          WORK is COMPLEX*16 array, dimension (LDWORK,N)


LDWORK

          LDWORK is INTEGER
          The leading dimension of the array WORK.  LDWORK >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RCOND

          RCOND is DOUBLE PRECISION
          The reciprocal of the condition number of A, computed as
          ( 1/norm(A) ) / norm(AINV).


RESID

          RESID is DOUBLE PRECISION
          norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zppt05 (character UPLO, integer N, integer NRHS, complex*16, dimension( * ) AP, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)

ZPPT05

Purpose:

 ZPPT05 tests the error bounds from iterative refinement for the
 computed solution to a system of equations A*X = B, where A is a
 Hermitian matrix in packed storage format.
 RESLTS(1) = test of the error bound
           = norm(X - XACT) / ( norm(X) * FERR )
 A large value is returned if this ratio is not less than one.
 RESLTS(2) = residual from the iterative refinement routine
           = the maximum of BERR / ( (n+1)*EPS + (*) ), where
             (*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows of the matrices X, B, and XACT, and the
          order of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of the matrices X, B, and XACT.
          NRHS >= 0.


AP

          AP is COMPLEX*16 array, dimension (N*(N+1)/2)
          The upper or lower triangle of the Hermitian matrix A, packed
          columnwise in a linear array.  The j-th column of A is stored
          in the array AP as follows:
          if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
          if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors.  Each vector is stored as a
          column of the matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


XACT

          XACT is COMPLEX*16 array, dimension (LDX,NRHS)
          The exact solution vectors.  Each vector is stored as a
          column of the matrix XACT.


LDXACT

          LDXACT is INTEGER
          The leading dimension of the array XACT.  LDXACT >= max(1,N).


FERR

          FERR is DOUBLE PRECISION array, dimension (NRHS)
          The estimated forward error bounds for each solution vector
          X.  If XTRUE is the true solution, FERR bounds the magnitude
          of the largest entry in (X - XTRUE) divided by the magnitude
          of the largest entry in X.


BERR

          BERR is DOUBLE PRECISION array, dimension (NRHS)
          The componentwise relative backward error of each solution
          vector (i.e., the smallest relative change in any entry of A
          or B that makes X an exact solution).


RESLTS

          RESLTS is DOUBLE PRECISION array, dimension (2)
          The maximum over the NRHS solution vectors of the ratios:
          RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
          RESLTS(2) = BERR / ( (n+1)*EPS + (*) )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zpst01 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, complex*16, dimension( ldperm, * ) PERM, integer LDPERM, integer, dimension( * ) PIV, double precision, dimension( * ) RWORK, double precision RESID, integer RANK)

ZPST01

Purpose:

 ZPST01 reconstructs an Hermitian positive semidefinite matrix A
 from its L or U factors and the permutation matrix P and computes
 the residual
    norm( P*L*L'*P' - A ) / ( N * norm(A) * EPS ) or
    norm( P*U'*U*P' - A ) / ( N * norm(A) * EPS ),
 where EPS is the machine epsilon, L' is the conjugate transpose of L,
 and U' is the conjugate transpose of U.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original Hermitian matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N)


AFAC

          AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
          The factor L or U from the L*L' or U'*U
          factorization of A.


LDAFAC

          LDAFAC is INTEGER
          The leading dimension of the array AFAC.  LDAFAC >= max(1,N).


PERM

          PERM is COMPLEX*16 array, dimension (LDPERM,N)
          Overwritten with the reconstructed matrix, and then with the
          difference P*L*L'*P' - A (or P*U'*U*P' - A)


LDPERM

          LDPERM is INTEGER
          The leading dimension of the array PERM.
          LDAPERM >= max(1,N).


PIV

          PIV is INTEGER array, dimension (N)
          PIV is such that the nonzero entries are
          P( PIV( K ), K ) = 1.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS )
          If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )


RANK

          RANK is INTEGER
          number of nonzero singular values of A.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zptt01 (integer N, double precision, dimension( * ) D, complex*16, dimension( * ) E, double precision, dimension( * ) DF, complex*16, dimension( * ) EF, complex*16, dimension( * ) WORK, double precision RESID)

ZPTT01

Purpose:

 ZPTT01 reconstructs a tridiagonal matrix A from its L*D*L'
 factorization and computes the residual
    norm(L*D*L' - A) / ( n * norm(A) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

N

          N is INTEGTER
          The order of the matrix A.


D

          D is DOUBLE PRECISION array, dimension (N)
          The n diagonal elements of the tridiagonal matrix A.


E

          E is COMPLEX*16 array, dimension (N-1)
          The (n-1) subdiagonal elements of the tridiagonal matrix A.


DF

          DF is DOUBLE PRECISION array, dimension (N)
          The n diagonal elements of the factor L from the L*D*L'
          factorization of A.


EF

          EF is COMPLEX*16 array, dimension (N-1)
          The (n-1) subdiagonal elements of the factor L from the
          L*D*L' factorization of A.


WORK

          WORK is COMPLEX*16 array, dimension (2*N)


RESID

          RESID is DOUBLE PRECISION
          norm(L*D*L' - A) / (n * norm(A) * EPS)


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zptt02 (character UPLO, integer N, integer NRHS, double precision, dimension( * ) D, complex*16, dimension( * ) E, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision RESID)

ZPTT02

Purpose:

 ZPTT02 computes the residual for the solution to a symmetric
 tridiagonal system of equations:
    RESID = norm(B - A*X) / (norm(A) * norm(X) * EPS),
 where EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the superdiagonal or the subdiagonal of the
          tridiagonal matrix A is stored.
          = 'U':  E is the superdiagonal of A
          = 'L':  E is the subdiagonal of A


N

          N is INTEGTER
          The order of the matrix A.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of columns
          of the matrices B and X.  NRHS >= 0.


D

          D is DOUBLE PRECISION array, dimension (N)
          The n diagonal elements of the tridiagonal matrix A.


E

          E is COMPLEX*16 array, dimension (N-1)
          The (n-1) subdiagonal elements of the tridiagonal matrix A.


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The n by nrhs matrix of solution vectors X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the n by nrhs matrix of right hand side vectors B.
          On exit, B is overwritten with the difference B - A*X.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


RESID

          RESID is DOUBLE PRECISION
          norm(B - A*X) / (norm(A) * norm(X) * EPS)


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zptt05 (integer N, integer NRHS, double precision, dimension( * ) D, complex*16, dimension( * ) E, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)

ZPTT05

Purpose:

 ZPTT05 tests the error bounds from iterative refinement for the
 computed solution to a system of equations A*X = B, where A is a
 Hermitian tridiagonal matrix of order n.
 RESLTS(1) = test of the error bound
           = norm(X - XACT) / ( norm(X) * FERR )
 A large value is returned if this ratio is not less than one.
 RESLTS(2) = residual from the iterative refinement routine
           = the maximum of BERR / ( NZ*EPS + (*) ), where
             (*) = NZ*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
             and NZ = max. number of nonzeros in any row of A, plus 1


 

Parameters:

N

          N is INTEGER
          The number of rows of the matrices X, B, and XACT, and the
          order of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of the matrices X, B, and XACT.
          NRHS >= 0.


D

          D is DOUBLE PRECISION array, dimension (N)
          The n diagonal elements of the tridiagonal matrix A.


E

          E is COMPLEX*16 array, dimension (N-1)
          The (n-1) subdiagonal elements of the tridiagonal matrix A.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors.  Each vector is stored as a
          column of the matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


XACT

          XACT is COMPLEX*16 array, dimension (LDX,NRHS)
          The exact solution vectors.  Each vector is stored as a
          column of the matrix XACT.


LDXACT

          LDXACT is INTEGER
          The leading dimension of the array XACT.  LDXACT >= max(1,N).


FERR

          FERR is DOUBLE PRECISION array, dimension (NRHS)
          The estimated forward error bounds for each solution vector
          X.  If XTRUE is the true solution, FERR bounds the magnitude
          of the largest entry in (X - XTRUE) divided by the magnitude
          of the largest entry in X.


BERR

          BERR is DOUBLE PRECISION array, dimension (NRHS)
          The componentwise relative backward error of each solution
          vector (i.e., the smallest relative change in any entry of A
          or B that makes X an exact solution).


RESLTS

          RESLTS is DOUBLE PRECISION array, dimension (2)
          The maximum over the NRHS solution vectors of the ratios:
          RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
          RESLTS(2) = BERR / ( NZ*EPS + (*) )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zqlt01 (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * ) L, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT)

ZQLT01

Purpose:

 ZQLT01 tests ZGEQLF, which computes the QL factorization of an m-by-n
 matrix A, and partially tests ZUNGQL which forms the m-by-m
 orthogonal matrix Q.
 ZQLT01 compares L with Q'*A, and checks that Q is orthogonal.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The m-by-n matrix A.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          Details of the QL factorization of A, as returned by ZGEQLF.
          See ZGEQLF for further details.


Q

          Q is COMPLEX*16 array, dimension (LDA,M)
          The m-by-m orthogonal matrix Q.


L

          L is COMPLEX*16 array, dimension (LDA,max(M,N))


LDA

          LDA is INTEGER
          The leading dimension of the arrays A, AF, Q and R.
          LDA >= max(M,N).


TAU

          TAU is COMPLEX*16 array, dimension (min(M,N))
          The scalar factors of the elementary reflectors, as returned
          by ZGEQLF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The dimension of the array WORK.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESULT

          RESULT is DOUBLE PRECISION array, dimension (2)
          The test ratios:
          RESULT(1) = norm( L - Q'*A ) / ( M * norm(A) * EPS )
          RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zqlt02 (integer M, integer N, integer K, complex*16, dimension( lda, * ) A, complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * ) L, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT)

ZQLT02

Purpose:

 ZQLT02 tests ZUNGQL, which generates an m-by-n matrix Q with
 orthonornmal columns that is defined as the product of k elementary
 reflectors.
 Given the QL factorization of an m-by-n matrix A, ZQLT02 generates
 the orthogonal matrix Q defined by the factorization of the last k
 columns of A; it compares L(m-n+1:m,n-k+1:n) with
 Q(1:m,m-n+1:m)'*A(1:m,n-k+1:n), and checks that the columns of Q are
 orthonormal.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix Q to be generated.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix Q to be generated.
          M >= N >= 0.


K

          K is INTEGER
          The number of elementary reflectors whose product defines the
          matrix Q. N >= K >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The m-by-n matrix A which was factorized by ZQLT01.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          Details of the QL factorization of A, as returned by ZGEQLF.
          See ZGEQLF for further details.


Q

          Q is COMPLEX*16 array, dimension (LDA,N)


L

          L is COMPLEX*16 array, dimension (LDA,N)


LDA

          LDA is INTEGER
          The leading dimension of the arrays A, AF, Q and L. LDA >= M.


TAU

          TAU is COMPLEX*16 array, dimension (N)
          The scalar factors of the elementary reflectors corresponding
          to the QL factorization in AF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The dimension of the array WORK.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESULT

          RESULT is DOUBLE PRECISION array, dimension (2)
          The test ratios:
          RESULT(1) = norm( L - Q'*A ) / ( M * norm(A) * EPS )
          RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zqlt03 (integer M, integer N, integer K, complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) C, complex*16, dimension( lda, * ) CC, complex*16, dimension( lda, * ) Q, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT)

ZQLT03

Purpose:

 ZQLT03 tests ZUNMQL, which computes Q*C, Q'*C, C*Q or C*Q'.
 ZQLT03 compares the results of a call to ZUNMQL with the results of
 forming Q explicitly by a call to ZUNGQL and then performing matrix
 multiplication by a call to ZGEMM.


 

Parameters:

M

          M is INTEGER
          The order of the orthogonal matrix Q.  M >= 0.


N

          N is INTEGER
          The number of rows or columns of the matrix C; C is m-by-n if
          Q is applied from the left, or n-by-m if Q is applied from
          the right.  N >= 0.


K

          K is INTEGER
          The number of elementary reflectors whose product defines the
          orthogonal matrix Q.  M >= K >= 0.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          Details of the QL factorization of an m-by-n matrix, as
          returned by ZGEQLF. See CGEQLF for further details.


C

          C is COMPLEX*16 array, dimension (LDA,N)


CC

          CC is COMPLEX*16 array, dimension (LDA,N)


Q

          Q is COMPLEX*16 array, dimension (LDA,M)


LDA

          LDA is INTEGER
          The leading dimension of the arrays AF, C, CC, and Q.


TAU

          TAU is COMPLEX*16 array, dimension (min(M,N))
          The scalar factors of the elementary reflectors corresponding
          to the QL factorization in AF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of WORK.  LWORK must be at least M, and should be
          M*NB, where NB is the blocksize for this environment.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESULT

          RESULT is DOUBLE PRECISION array, dimension (4)
          The test ratios compare two techniques for multiplying a
          random matrix C by an m-by-m orthogonal matrix Q.
          RESULT(1) = norm( Q*C - Q*C )  / ( M * norm(C) * EPS )
          RESULT(2) = norm( C*Q - C*Q )  / ( M * norm(C) * EPS )
          RESULT(3) = norm( Q'*C - Q'*C )/ ( M * norm(C) * EPS )
          RESULT(4) = norm( C*Q' - C*Q' )/ ( M * norm(C) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

double precision function zqpt01 (integer M, integer N, integer K, complex*16, dimension( lda, * ) A, complex*16, dimension( lda, * ) AF, integer LDA, complex*16, dimension( * ) TAU, integer, dimension( * ) JPVT, complex*16, dimension( lwork ) WORK, integer LWORK)

ZQPT01

Purpose:

 ZQPT01 tests the QR-factorization with pivoting of a matrix A.  The
 array AF contains the (possibly partial) QR-factorization of A, where
 the upper triangle of AF(1:k,1:k) is a partial triangular factor,
 the entries below the diagonal in the first k columns are the
 Householder vectors, and the rest of AF contains a partially updated
 matrix.
 This function returns ||A*P - Q*R||/(||norm(A)||*eps*M)


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrices A and AF.


N

          N is INTEGER
          The number of columns of the matrices A and AF.


K

          K is INTEGER
          The number of columns of AF that have been reduced
          to upper triangular form.


A

          A is COMPLEX*16 array, dimension (LDA, N)
          The original matrix A.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          The (possibly partial) output of ZGEQPF.  The upper triangle
          of AF(1:k,1:k) is a partial triangular factor, the entries
          below the diagonal in the first k columns are the Householder
          vectors, and the rest of AF contains a partially updated
          matrix.


LDA

          LDA is INTEGER
          The leading dimension of the arrays A and AF.


TAU

          TAU is COMPLEX*16 array, dimension (K)
          Details of the Householder transformations as returned by
          ZGEQPF.


JPVT

          JPVT is INTEGER array, dimension (N)
          Pivot information as returned by ZGEQPF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of the array WORK.  LWORK >= M*N+N.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zqrt01 (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * ) R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT)

ZQRT01

Purpose:

 ZQRT01 tests ZGEQRF, which computes the QR factorization of an m-by-n
 matrix A, and partially tests ZUNGQR which forms the m-by-m
 orthogonal matrix Q.
 ZQRT01 compares R with Q'*A, and checks that Q is orthogonal.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The m-by-n matrix A.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          Details of the QR factorization of A, as returned by ZGEQRF.
          See ZGEQRF for further details.


Q

          Q is COMPLEX*16 array, dimension (LDA,M)
          The m-by-m orthogonal matrix Q.


R

          R is COMPLEX*16 array, dimension (LDA,max(M,N))


LDA

          LDA is INTEGER
          The leading dimension of the arrays A, AF, Q and R.
          LDA >= max(M,N).


TAU

          TAU is COMPLEX*16 array, dimension (min(M,N))
          The scalar factors of the elementary reflectors, as returned
          by ZGEQRF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The dimension of the array WORK.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESULT

          RESULT is DOUBLE PRECISION array, dimension (2)
          The test ratios:
          RESULT(1) = norm( R - Q'*A ) / ( M * norm(A) * EPS )
          RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zqrt01p (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * ) R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT)

ZQRT01P

Purpose:

 ZQRT01P tests ZGEQRFP, which computes the QR factorization of an m-by-n
 matrix A, and partially tests ZUNGQR which forms the m-by-m
 orthogonal matrix Q.
 ZQRT01P compares R with Q'*A, and checks that Q is orthogonal.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The m-by-n matrix A.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          Details of the QR factorization of A, as returned by ZGEQRFP.
          See ZGEQRFP for further details.


Q

          Q is COMPLEX*16 array, dimension (LDA,M)
          The m-by-m orthogonal matrix Q.


R

          R is COMPLEX*16 array, dimension (LDA,max(M,N))


LDA

          LDA is INTEGER
          The leading dimension of the arrays A, AF, Q and R.
          LDA >= max(M,N).


TAU

          TAU is COMPLEX*16 array, dimension (min(M,N))
          The scalar factors of the elementary reflectors, as returned
          by ZGEQRFP.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The dimension of the array WORK.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESULT

          RESULT is DOUBLE PRECISION array, dimension (2)
          The test ratios:
          RESULT(1) = norm( R - Q'*A ) / ( M * norm(A) * EPS )
          RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zqrt02 (integer M, integer N, integer K, complex*16, dimension( lda, * ) A, complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * ) R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT)

ZQRT02

Purpose:

 ZQRT02 tests ZUNGQR, which generates an m-by-n matrix Q with
 orthonornmal columns that is defined as the product of k elementary
 reflectors.
 Given the QR factorization of an m-by-n matrix A, ZQRT02 generates
 the orthogonal matrix Q defined by the factorization of the first k
 columns of A; it compares R(1:n,1:k) with Q(1:m,1:n)'*A(1:m,1:k),
 and checks that the columns of Q are orthonormal.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix Q to be generated.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix Q to be generated.
          M >= N >= 0.


K

          K is INTEGER
          The number of elementary reflectors whose product defines the
          matrix Q. N >= K >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The m-by-n matrix A which was factorized by ZQRT01.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          Details of the QR factorization of A, as returned by ZGEQRF.
          See ZGEQRF for further details.


Q

          Q is COMPLEX*16 array, dimension (LDA,N)


R

          R is COMPLEX*16 array, dimension (LDA,N)


LDA

          LDA is INTEGER
          The leading dimension of the arrays A, AF, Q and R. LDA >= M.


TAU

          TAU is COMPLEX*16 array, dimension (N)
          The scalar factors of the elementary reflectors corresponding
          to the QR factorization in AF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The dimension of the array WORK.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESULT

          RESULT is DOUBLE PRECISION array, dimension (2)
          The test ratios:
          RESULT(1) = norm( R - Q'*A ) / ( M * norm(A) * EPS )
          RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zqrt03 (integer M, integer N, integer K, complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) C, complex*16, dimension( lda, * ) CC, complex*16, dimension( lda, * ) Q, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT)

ZQRT03

Purpose:

 ZQRT03 tests ZUNMQR, which computes Q*C, Q'*C, C*Q or C*Q'.
 ZQRT03 compares the results of a call to ZUNMQR with the results of
 forming Q explicitly by a call to ZUNGQR and then performing matrix
 multiplication by a call to ZGEMM.


 

Parameters:

M

          M is INTEGER
          The order of the orthogonal matrix Q.  M >= 0.


N

          N is INTEGER
          The number of rows or columns of the matrix C; C is m-by-n if
          Q is applied from the left, or n-by-m if Q is applied from
          the right.  N >= 0.


K

          K is INTEGER
          The number of elementary reflectors whose product defines the
          orthogonal matrix Q.  M >= K >= 0.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          Details of the QR factorization of an m-by-n matrix, as
          returned by ZGEQRF. See ZGEQRF for further details.


C

          C is COMPLEX*16 array, dimension (LDA,N)


CC

          CC is COMPLEX*16 array, dimension (LDA,N)


Q

          Q is COMPLEX*16 array, dimension (LDA,M)


LDA

          LDA is INTEGER
          The leading dimension of the arrays AF, C, CC, and Q.


TAU

          TAU is COMPLEX*16 array, dimension (min(M,N))
          The scalar factors of the elementary reflectors corresponding
          to the QR factorization in AF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of WORK.  LWORK must be at least M, and should be
          M*NB, where NB is the blocksize for this environment.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESULT

          RESULT is DOUBLE PRECISION array, dimension (4)
          The test ratios compare two techniques for multiplying a
          random matrix C by an m-by-m orthogonal matrix Q.
          RESULT(1) = norm( Q*C - Q*C )  / ( M * norm(C) * EPS )
          RESULT(2) = norm( C*Q - C*Q )  / ( M * norm(C) * EPS )
          RESULT(3) = norm( Q'*C - Q'*C )/ ( M * norm(C) * EPS )
          RESULT(4) = norm( C*Q' - C*Q' )/ ( M * norm(C) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

subroutine zqrt04 (integer M, integer N, integer NB, double precision, dimension(6) RESULT)

ZQRT04

Purpose:

 ZQRT04 tests ZGEQRT and ZGEMQRT.


 

Parameters:

M

          M is INTEGER
          Number of rows in test matrix.


N

          N is INTEGER
          Number of columns in test matrix.


NB

          NB is INTEGER
          Block size of test matrix.  NB <= Min(M,N).


RESULT

          RESULT is DOUBLE PRECISION array, dimension (6)
          Results of each of the six tests below.
          RESULT(1) = | A - Q R |
          RESULT(2) = | I - Q^H Q |
          RESULT(3) = | Q C - Q C |
          RESULT(4) = | Q^H C - Q^H C |
          RESULT(5) = | C Q - C Q | 
          RESULT(6) = | C Q^H - C Q^H |


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

subroutine zqrt05 (integer M, integer N, integer L, integer NB, double precision, dimension(6) RESULT)

ZQRT05

Purpose:

 ZQRT05 tests ZTPQRT and ZTPMQRT.


 

Parameters:

M

          M is INTEGER
          Number of rows in lower part of the test matrix.


N

          N is INTEGER
          Number of columns in test matrix.


L

          L is INTEGER
          The number of rows of the upper trapezoidal part the
          lower test matrix.  0 <= L <= M.


NB

          NB is INTEGER
          Block size of test matrix.  NB <= N.


RESULT

          RESULT is DOUBLE PRECISION array, dimension (6)
          Results of each of the six tests below.
          RESULT(1) = | A - Q R |
          RESULT(2) = | I - Q^H Q |
          RESULT(3) = | Q C - Q C |
          RESULT(4) = | Q^H C - Q^H C |
          RESULT(5) = | C Q - C Q | 
          RESULT(6) = | C Q^H - C Q^H |


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

double precision function zqrt11 (integer M, integer K, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK)

ZQRT11

Purpose:

 ZQRT11 computes the test ratio
       || Q'*Q - I || / (eps * m)
 where the orthogonal matrix Q is represented as a product of
 elementary transformations.  Each transformation has the form
    H(k) = I - tau(k) v(k) v(k)'
 where tau(k) is stored in TAU(k) and v(k) is an m-vector of the form
 [ 0 ... 0 1 x(k) ]', where x(k) is a vector of length m-k stored
 in A(k+1:m,k).


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.


K

          K is INTEGER
          The number of columns of A whose subdiagonal entries
          contain information about orthogonal transformations.


A

          A is COMPLEX*16 array, dimension (LDA,K)
          The (possibly partial) output of a QR reduction routine.


LDA

          LDA is INTEGER
          The leading dimension of the array A.


TAU

          TAU is COMPLEX*16 array, dimension (K)
          The scaling factors tau for the elementary transformations as
          computed by the QR factorization routine.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of the array WORK.  LWORK >= M*M + M.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

double precision function zqrt12 (integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) S, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK)

ZQRT12

Purpose:

 ZQRT12 computes the singular values `svlues' of the upper trapezoid
 of A(1:M,1:N) and returns the ratio
      || s - svlues||/(||svlues||*eps*max(M,N))


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.


N

          N is INTEGER
          The number of columns of the matrix A.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The M-by-N matrix A. Only the upper trapezoid is referenced.


LDA

          LDA is INTEGER
          The leading dimension of the array A.


S

          S is DOUBLE PRECISION array, dimension (min(M,N))
          The singular values of the matrix A.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of the array WORK. LWORK >= M*N + 2*min(M,N) +
          max(M,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (2*min(M,N))


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zqrt13 (integer SCALE, integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA, double precision NORMA, integer, dimension( 4 ) ISEED)

ZQRT13

Purpose:

 ZQRT13 generates a full-rank matrix that may be scaled to have large
 or small norm.


 

Parameters:

SCALE

          SCALE is INTEGER
          SCALE = 1: normally scaled matrix
          SCALE = 2: matrix scaled up
          SCALE = 3: matrix scaled down


M

          M is INTEGER
          The number of rows of the matrix A.


N

          N is INTEGER
          The number of columns of A.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The M-by-N matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.


NORMA

          NORMA is DOUBLE PRECISION
          The one-norm of A.


ISEED

          ISEED is integer array, dimension (4)
          Seed for random number generator


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

double precision function zqrt14 (character TRANS, integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( lwork ) WORK, integer LWORK)

ZQRT14

Purpose:

 ZQRT14 checks whether X is in the row space of A or A'.  It does so
 by scaling both X and A such that their norms are in the range
 [sqrt(eps), 1/sqrt(eps)], then computing a QR factorization of [A,X]
 (if TRANS = 'C') or an LQ factorization of [A',X]' (if TRANS = 'N'),
 and returning the norm of the trailing triangle, scaled by
 MAX(M,N,NRHS)*eps.


 

Parameters:

TRANS

          TRANS is CHARACTER*1
          = 'N':  No transpose, check for X in the row space of A
          = 'C':  Conjugate transpose, check for X in row space of A'.


M

          M is INTEGER
          The number of rows of the matrix A.


N

          N is INTEGER
          The number of columns of the matrix A.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of columns
          of X.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The M-by-N matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          If TRANS = 'N', the N-by-NRHS matrix X.
          IF TRANS = 'C', the M-by-NRHS matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.


WORK

          WORK is COMPLEX*16 array dimension (LWORK)


LWORK

          LWORK is INTEGER
          length of workspace array required
          If TRANS = 'N', LWORK >= (M+NRHS)*(N+2);
          if TRANS = 'C', LWORK >= (N+NRHS)*(M+2).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zqrt15 (integer SCALE, integer RKSEL, integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) S, integer RANK, double precision NORMA, double precision NORMB, integer, dimension( 4 ) ISEED, complex*16, dimension( lwork ) WORK, integer LWORK)

ZQRT15

Purpose:

 ZQRT15 generates a matrix with full or deficient rank and of various
 norms.


 

Parameters:

SCALE

          SCALE is INTEGER
          SCALE = 1: normally scaled matrix
          SCALE = 2: matrix scaled up
          SCALE = 3: matrix scaled down


RKSEL

          RKSEL is INTEGER
          RKSEL = 1: full rank matrix
          RKSEL = 2: rank-deficient matrix


M

          M is INTEGER
          The number of rows of the matrix A.


N

          N is INTEGER
          The number of columns of A.


NRHS

          NRHS is INTEGER
          The number of columns of B.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The M-by-N matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.


B

          B is COMPLEX*16 array, dimension (LDB, NRHS)
          A matrix that is in the range space of matrix A.


LDB

          LDB is INTEGER
          The leading dimension of the array B.


S

          S is DOUBLE PRECISION array, dimension MIN(M,N)
          Singular values of A.


RANK

          RANK is INTEGER
          number of nonzero singular values of A.


NORMA

          NORMA is DOUBLE PRECISION
          one-norm norm of A.


NORMB

          NORMB is DOUBLE PRECISION
          one-norm norm of B.


ISEED

          ISEED is integer array, dimension (4)
          seed for random number generator.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          length of work space required.
          LWORK >= MAX(M+MIN(M,N),NRHS*MIN(M,N),2*N+M)


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zqrt16 (character TRANS, integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)

ZQRT16

Purpose:

 ZQRT16 computes the residual for a solution of a system of linear
 equations  A*x = b  or  A'*x = b:
    RESID = norm(B - A*X) / ( max(m,n) * norm(A) * norm(X) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

TRANS

          TRANS is CHARACTER*1
          Specifies the form of the system of equations:
          = 'N':  A *x = b
          = 'T':  A^T*x = b, where A^T is the transpose of A
          = 'C':  A^H*x = b, where A^H is the conjugate transpose of A


M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of B, the matrix of right hand sides.
          NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original M x N matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,M).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  If TRANS = 'N',
          LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the right hand side vectors for the system of
          linear equations.
          On exit, B is overwritten with the difference B - A*X.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  IF TRANS = 'N',
          LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(B - A*X) / ( max(m,n) * norm(A) * norm(X) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

double precision function zqrt17 (character TRANS, integer IRESID, integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldb, * ) C, complex*16, dimension( lwork ) WORK, integer LWORK)

ZQRT17

Purpose:

 ZQRT17 computes the ratio
    || R'*op(A) ||/(||A||*alpha*max(M,N,NRHS)*eps)
 where R = op(A)*X - B, op(A) is A or A', and
    alpha = ||B|| if IRESID = 1 (zero-residual problem)
    alpha = ||R|| if IRESID = 2 (otherwise).


 

Parameters:

TRANS

          TRANS is CHARACTER*1
          Specifies whether or not the transpose of A is used.
          = 'N':  No transpose, op(A) = A.
          = 'C':  Conjugate transpose, op(A) = A'.


IRESID

          IRESID is INTEGER
          IRESID = 1 indicates zero-residual problem.
          IRESID = 2 indicates non-zero residual.


M

          M is INTEGER
          The number of rows of the matrix A.
          If TRANS = 'N', the number of rows of the matrix B.
          If TRANS = 'C', the number of rows of the matrix X.


N

          N is INTEGER
          The number of columns of the matrix  A.
          If TRANS = 'N', the number of rows of the matrix X.
          If TRANS = 'C', the number of rows of the matrix B.


NRHS

          NRHS is INTEGER
          The number of columns of the matrices X and B.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The m-by-n matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A. LDA >= M.


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          If TRANS = 'N', the n-by-nrhs matrix X.
          If TRANS = 'C', the m-by-nrhs matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.
          If TRANS = 'N', LDX >= N.
          If TRANS = 'C', LDX >= M.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          If TRANS = 'N', the m-by-nrhs matrix B.
          If TRANS = 'C', the n-by-nrhs matrix B.


LDB

          LDB is INTEGER
          The leading dimension of the array B.
          If TRANS = 'N', LDB >= M.
          If TRANS = 'C', LDB >= N.


C

          C is COMPLEX*16 array, dimension (LDB,NRHS)


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of the array WORK.  LWORK >= NRHS*(M+N).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2015

subroutine zrqt01 (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * ) R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT)

ZRQT01

Purpose:

 ZRQT01 tests ZGERQF, which computes the RQ factorization of an m-by-n
 matrix A, and partially tests ZUNGRQ which forms the n-by-n
 orthogonal matrix Q.
 ZRQT01 compares R with A*Q', and checks that Q is orthogonal.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix A.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The m-by-n matrix A.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          Details of the RQ factorization of A, as returned by ZGERQF.
          See ZGERQF for further details.


Q

          Q is COMPLEX*16 array, dimension (LDA,N)
          The n-by-n orthogonal matrix Q.


R

          R is COMPLEX*16 array, dimension (LDA,max(M,N))


LDA

          LDA is INTEGER
          The leading dimension of the arrays A, AF, Q and L.
          LDA >= max(M,N).


TAU

          TAU is COMPLEX*16 array, dimension (min(M,N))
          The scalar factors of the elementary reflectors, as returned
          by ZGERQF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The dimension of the array WORK.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (max(M,N))


RESULT

          RESULT is DOUBLE PRECISION array, dimension (2)
          The test ratios:
          RESULT(1) = norm( R - A*Q' ) / ( N * norm(A) * EPS )
          RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zrqt02 (integer M, integer N, integer K, complex*16, dimension( lda, * ) A, complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * ) R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT)

ZRQT02

Purpose:

 ZRQT02 tests ZUNGRQ, which generates an m-by-n matrix Q with
 orthonornmal rows that is defined as the product of k elementary
 reflectors.
 Given the RQ factorization of an m-by-n matrix A, ZRQT02 generates
 the orthogonal matrix Q defined by the factorization of the last k
 rows of A; it compares R(m-k+1:m,n-m+1:n) with
 A(m-k+1:m,1:n)*Q(n-m+1:n,1:n)', and checks that the rows of Q are
 orthonormal.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix Q to be generated.  M >= 0.


N

          N is INTEGER
          The number of columns of the matrix Q to be generated.
          N >= M >= 0.


K

          K is INTEGER
          The number of elementary reflectors whose product defines the
          matrix Q. M >= K >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The m-by-n matrix A which was factorized by ZRQT01.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          Details of the RQ factorization of A, as returned by ZGERQF.
          See ZGERQF for further details.


Q

          Q is COMPLEX*16 array, dimension (LDA,N)


R

          R is COMPLEX*16 array, dimension (LDA,M)


LDA

          LDA is INTEGER
          The leading dimension of the arrays A, AF, Q and L. LDA >= N.


TAU

          TAU is COMPLEX*16 array, dimension (M)
          The scalar factors of the elementary reflectors corresponding
          to the RQ factorization in AF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The dimension of the array WORK.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESULT

          RESULT is DOUBLE PRECISION array, dimension (2)
          The test ratios:
          RESULT(1) = norm( R - A*Q' ) / ( N * norm(A) * EPS )
          RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zrqt03 (integer M, integer N, integer K, complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) C, complex*16, dimension( lda, * ) CC, complex*16, dimension( lda, * ) Q, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT)

ZRQT03

Purpose:

 ZRQT03 tests ZUNMRQ, which computes Q*C, Q'*C, C*Q or C*Q'.
 ZRQT03 compares the results of a call to ZUNMRQ with the results of
 forming Q explicitly by a call to ZUNGRQ and then performing matrix
 multiplication by a call to ZGEMM.


 

Parameters:

M

          M is INTEGER
          The number of rows or columns of the matrix C; C is n-by-m if
          Q is applied from the left, or m-by-n if Q is applied from
          the right.  M >= 0.


N

          N is INTEGER
          The order of the orthogonal matrix Q.  N >= 0.


K

          K is INTEGER
          The number of elementary reflectors whose product defines the
          orthogonal matrix Q.  N >= K >= 0.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          Details of the RQ factorization of an m-by-n matrix, as
          returned by ZGERQF. See CGERQF for further details.


C

          C is COMPLEX*16 array, dimension (LDA,N)


CC

          CC is COMPLEX*16 array, dimension (LDA,N)


Q

          Q is COMPLEX*16 array, dimension (LDA,N)


LDA

          LDA is INTEGER
          The leading dimension of the arrays AF, C, CC, and Q.


TAU

          TAU is COMPLEX*16 array, dimension (min(M,N))
          The scalar factors of the elementary reflectors corresponding
          to the RQ factorization in AF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of WORK.  LWORK must be at least M, and should be
          M*NB, where NB is the blocksize for this environment.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (M)


RESULT

          RESULT is DOUBLE PRECISION array, dimension (4)
          The test ratios compare two techniques for multiplying a
          random matrix C by an n-by-n orthogonal matrix Q.
          RESULT(1) = norm( Q*C - Q*C )  / ( N * norm(C) * EPS )
          RESULT(2) = norm( C*Q - C*Q )  / ( N * norm(C) * EPS )
          RESULT(3) = norm( Q'*C - Q'*C )/ ( N * norm(C) * EPS )
          RESULT(4) = norm( C*Q' - C*Q' )/ ( N * norm(C) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

double precision function zrzt01 (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16, dimension( lda, * ) AF, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK)

ZRZT01

Purpose:

 ZRZT01 returns
      || A - R*Q || / ( M * eps * ||A|| )
 for an upper trapezoidal A that was factored with ZTZRZF.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrices A and AF.


N

          N is INTEGER
          The number of columns of the matrices A and AF.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original upper trapezoidal M by N matrix A.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          The output of ZTZRZF for input matrix A.
          The lower triangle is not referenced.


LDA

          LDA is INTEGER
          The leading dimension of the arrays A and AF.


TAU

          TAU is COMPLEX*16 array, dimension (M)
          Details of the  Householder transformations as returned by
          ZTZRZF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          The length of the array WORK.  LWORK >= m*n + m.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

double precision function zrzt02 (integer M, integer N, complex*16, dimension( lda, * ) AF, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer LWORK)

ZRZT02

Purpose:

 ZRZT02 returns
      || I - Q'*Q || / ( M * eps)
 where the matrix Q is defined by the Householder transformations
 generated by ZTZRZF.


 

Parameters:

M

          M is INTEGER
          The number of rows of the matrix AF.


N

          N is INTEGER
          The number of columns of the matrix AF.


AF

          AF is COMPLEX*16 array, dimension (LDA,N)
          The output of ZTZRZF.


LDA

          LDA is INTEGER
          The leading dimension of the array AF.


TAU

          TAU is COMPLEX*16 array, dimension (M)
          Details of the Householder transformations as returned by
          ZTZRZF.


WORK

          WORK is COMPLEX*16 array, dimension (LWORK)


LWORK

          LWORK is INTEGER
          Length of WORK array. LWORK >= N*N+N.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zsbmv (character UPLO, integer N, integer K, complex*16 ALPHA, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) X, integer INCX, complex*16 BETA, complex*16, dimension( * ) Y, integer INCY)

ZSBMV

Purpose:

 ZSBMV  performs the matrix-vector  operation
    y := alpha*A*x + beta*y,
 where alpha and beta are scalars, x and y are n element vectors and
 A is an n by n symmetric band matrix, with k super-diagonals.


 

  UPLO   - CHARACTER*1
           On entry, UPLO specifies whether the upper or lower
           triangular part of the band matrix A is being supplied as
           follows:
              UPLO = 'U' or 'u'   The upper triangular part of A is
                                  being supplied.
              UPLO = 'L' or 'l'   The lower triangular part of A is
                                  being supplied.
           Unchanged on exit.
  N      - INTEGER
           On entry, N specifies the order of the matrix A.
           N must be at least zero.
           Unchanged on exit.
  K      - INTEGER
           On entry, K specifies the number of super-diagonals of the
           matrix A. K must satisfy  0 .le. K.
           Unchanged on exit.
  ALPHA  - COMPLEX*16
           On entry, ALPHA specifies the scalar alpha.
           Unchanged on exit.
  A      - COMPLEX*16 array, dimension( LDA, N )
           Before entry with UPLO = 'U' or 'u', the leading ( k + 1 )
           by n part of the array A must contain the upper triangular
           band part of the symmetric matrix, supplied column by
           column, with the leading diagonal of the matrix in row
           ( k + 1 ) of the array, the first super-diagonal starting at
           position 2 in row k, and so on. The top left k by k triangle
           of the array A is not referenced.
           The following program segment will transfer the upper
           triangular part of a symmetric band matrix from conventional
           full matrix storage to band storage:
                 DO 20, J = 1, N
                    M = K + 1 - J
                    DO 10, I = MAX( 1, J - K ), J
                       A( M + I, J ) = matrix( I, J )
              10    CONTINUE
              20 CONTINUE
           Before entry with UPLO = 'L' or 'l', the leading ( k + 1 )
           by n part of the array A must contain the lower triangular
           band part of the symmetric matrix, supplied column by
           column, with the leading diagonal of the matrix in row 1 of
           the array, the first sub-diagonal starting at position 1 in
           row 2, and so on. The bottom right k by k triangle of the
           array A is not referenced.
           The following program segment will transfer the lower
           triangular part of a symmetric band matrix from conventional
           full matrix storage to band storage:
                 DO 20, J = 1, N
                    M = 1 - J
                    DO 10, I = J, MIN( N, J + K )
                       A( M + I, J ) = matrix( I, J )
              10    CONTINUE
              20 CONTINUE
           Unchanged on exit.
  LDA    - INTEGER
           On entry, LDA specifies the first dimension of A as declared
           in the calling (sub) program. LDA must be at least
           ( k + 1 ).
           Unchanged on exit.
  X      - COMPLEX*16 array, dimension at least
           ( 1 + ( N - 1 )*abs( INCX ) ).
           Before entry, the incremented array X must contain the
           vector x.
           Unchanged on exit.
  INCX   - INTEGER
           On entry, INCX specifies the increment for the elements of
           X. INCX must not be zero.
           Unchanged on exit.
  BETA   - COMPLEX*16
           On entry, BETA specifies the scalar beta.
           Unchanged on exit.
  Y      - COMPLEX*16 array, dimension at least
           ( 1 + ( N - 1 )*abs( INCY ) ).
           Before entry, the incremented array Y must contain the
           vector y. On exit, Y is overwritten by the updated vector y.
  INCY   - INTEGER
           On entry, INCY specifies the increment for the elements of
           Y. INCY must not be zero.
           Unchanged on exit.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zspt01 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, integer, dimension( * ) IPIV, complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) RWORK, double precision RESID)

ZSPT01

Purpose:

 ZSPT01 reconstructs a symmetric indefinite packed matrix A from its
 diagonal pivoting factorization A = U*D*U' or A = L*D*L' and computes
 the residual
    norm( C - A ) / ( N * norm(A) * EPS ),
 where C is the reconstructed matrix and EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          Hermitian matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The order of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (N*(N+1)/2)
          The original symmetric matrix A, stored as a packed
          triangular matrix.


AFAC

          AFAC is COMPLEX*16 array, dimension (N*(N+1)/2)
          The factored form of the matrix A, stored as a packed
          triangular matrix.  AFAC contains the block diagonal matrix D
          and the multipliers used to obtain the factor L or U from the
          L*D*L' or U*D*U' factorization as computed by ZSPTRF.


IPIV

          IPIV is INTEGER array, dimension (N)
          The pivot indices from ZSPTRF.


C

          C is COMPLEX*16 array, dimension (LDC,N)


LDC

          LDC is INTEGER
          The leading dimension of the array C.  LDC >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
          If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zspt02 (character UPLO, integer N, integer NRHS, complex*16, dimension( * ) A, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)

ZSPT02

Purpose:

 ZSPT02 computes the residual in the solution of a complex symmetric
 system of linear equations  A*x = b  when packed storage is used for
 the coefficient matrix.  The ratio computed is
    RESID = norm( B - A*X ) / ( norm(A) * norm(X) * EPS).
 where EPS is the machine precision.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          complex symmetric matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of B, the matrix of right hand sides.
          NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (N*(N+1)/2)
          The original complex symmetric matrix A, stored as a packed
          triangular matrix.


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.   LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the right hand side vectors for the system of
          linear equations.
          On exit, B is overwritten with the difference B - A*X.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(B - A*X) / ( norm(A) * norm(X) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zspt03 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16, dimension( * ) AINV, complex*16, dimension( ldw, * ) WORK, integer LDW, double precision, dimension( * ) RWORK, double precision RCOND, double precision RESID)

ZSPT03

Purpose:

 ZSPT03 computes the residual for a complex symmetric packed matrix
 times its inverse:
    norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          complex symmetric matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (N*(N+1)/2)
          The original complex symmetric matrix A, stored as a packed
          triangular matrix.


AINV

          AINV is COMPLEX*16 array, dimension (N*(N+1)/2)
          The (symmetric) inverse of the matrix A, stored as a packed
          triangular matrix.


WORK

          WORK is COMPLEX*16 array, dimension (LDW,N)


LDW

          LDW is INTEGER
          The leading dimension of the array WORK.  LDW >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RCOND

          RCOND is DOUBLE PRECISION
          The reciprocal of the condition number of A, computed as
          ( 1/norm(A) ) / norm(AINV).


RESID

          RESID is DOUBLE PRECISION
          norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zsyt01 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * ) IPIV, complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) RWORK, double precision RESID)

ZSYT01

Purpose:

 ZSYT01 reconstructs a complex symmetric indefinite matrix A from its
 block L*D*L' or U*D*U' factorization and computes the residual
    norm( C - A ) / ( N * norm(A) * EPS ),
 where C is the reconstructed matrix, EPS is the machine epsilon,
 L' is the transpose of L, and U' is the transpose of U.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          complex symmetric matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original complex symmetric matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N)


AFAC

          AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
          The factored form of the matrix A.  AFAC contains the block
          diagonal matrix D and the multipliers used to obtain the
          factor L or U from the block L*D*L' or U*D*U' factorization
          as computed by ZSYTRF.


LDAFAC

          LDAFAC is INTEGER
          The leading dimension of the array AFAC.  LDAFAC >= max(1,N).


IPIV

          IPIV is INTEGER array, dimension (N)
          The pivot indices from ZSYTRF.


C

          C is COMPLEX*16 array, dimension (LDC,N)


LDC

          LDC is INTEGER
          The leading dimension of the array C.  LDC >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
          If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

subroutine zsyt01_rook (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * ) IPIV, complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) RWORK, double precision RESID)

ZSYT01_ROOK

Purpose:

 ZSYT01_ROOK reconstructs a complex symmetric indefinite matrix A from its
 block L*D*L' or U*D*U' factorization and computes the residual
    norm( C - A ) / ( N * norm(A) * EPS ),
 where C is the reconstructed matrix, EPS is the machine epsilon,
 L' is the transpose of L, and U' is the transpose of U.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          complex symmetric matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original complex symmetric matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N)


AFAC

          AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
          The factored form of the matrix A.  AFAC contains the block
          diagonal matrix D and the multipliers used to obtain the
          factor L or U from the block L*D*L' or U*D*U' factorization
          as computed by ZSYTRF_ROOK.


LDAFAC

          LDAFAC is INTEGER
          The leading dimension of the array AFAC.  LDAFAC >= max(1,N).


IPIV

          IPIV is INTEGER array, dimension (N)
          The pivot indices from ZSYTRF_ROOK.


C

          C is COMPLEX*16 array, dimension (LDC,N)


LDC

          LDC is INTEGER
          The leading dimension of the array C.  LDC >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
          If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2013

subroutine zsyt02 (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)

ZSYT02

Purpose:

 ZSYT02 computes the residual for a solution to a complex symmetric
 system of linear equations  A*x = b:
    RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          symmetric matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of B, the matrix of right hand sides.
          NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original complex symmetric matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N)


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.   LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          On entry, the right hand side vectors for the system of
          linear equations.
          On exit, B is overwritten with the difference B - A*X.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(B - A*X) / ( norm(A) * norm(X) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine zsyt03 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldainv, * ) AINV, integer LDAINV, complex*16, dimension( ldwork, * ) WORK, integer LDWORK, double precision, dimension( * ) RWORK, double precision RCOND, double precision RESID)

ZSYT03

Purpose:

 ZSYT03 computes the residual for a complex symmetric matrix times
 its inverse:
    norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS )
 where EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the upper or lower triangular part of the
          complex symmetric matrix A is stored:
          = 'U':  Upper triangular
          = 'L':  Lower triangular


N

          N is INTEGER
          The number of rows and columns of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The original complex symmetric matrix A.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N)


AINV

          AINV is COMPLEX*16 array, dimension (LDAINV,N)
          On entry, the inverse of the matrix A, stored as a symmetric
          matrix in the same format as A.
          In this version, AINV is expanded into a full matrix and
          multiplied by A, so the opposing triangle of AINV will be
          changed; i.e., if the upper triangular part of AINV is
          stored, the lower triangular part will be used as work space.


LDAINV

          LDAINV is INTEGER
          The leading dimension of the array AINV.  LDAINV >= max(1,N).


WORK

          WORK is COMPLEX*16 array, dimension (LDWORK,N)


LDWORK

          LDWORK is INTEGER
          The leading dimension of the array WORK.  LDWORK >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RCOND

          RCOND is DOUBLE PRECISION
          The reciprocal of the condition number of A, computed as
          RCOND = 1/ (norm(A) * norm(AINV)).


RESID

          RESID is DOUBLE PRECISION
          norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztbt02 (character UPLO, character TRANS, character DIAG, integer N, integer KD, integer NRHS, complex*16, dimension( ldab, * ) AB, integer LDAB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, double precision RESID)

ZTBT02

Purpose:

 ZTBT02 computes the residual for the computed solution to a
 triangular system of linear equations  A*x = b,  A**T *x = b,  or
 A**H *x = b  when A is a triangular band matrix.  Here A**T denotes
 the transpose of A, A**H denotes the conjugate transpose of A, and
 x and b are N by NRHS matrices.  The test ratio is the maximum over
 the number of right hand sides of
    norm(b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
 where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the operation applied to A.
          = 'N':  A *x = b     (No transpose)
          = 'T':  A**T *x = b  (Transpose)
          = 'C':  A**H *x = b  (Conjugate transpose)


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The order of the matrix A.  N >= 0.


KD

          KD is INTEGER
          The number of superdiagonals or subdiagonals of the
          triangular band matrix A.  KD >= 0.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of columns
          of the matrices X and B.  NRHS >= 0.


AB

          AB is COMPLEX*16 array, dimension (LDA,N)
          The upper or lower triangular band matrix A, stored in the
          first kd+1 rows of the array. The j-th column of A is stored
          in the j-th column of the array AB as follows:
          if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
          if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).


LDAB

          LDAB is INTEGER
          The leading dimension of the array AB.  LDAB >= max(1,KD+1).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


WORK

          WORK is COMPLEX*16 array, dimension (N)


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(op(A)*x - b) / ( norm(op(A)) * norm(x) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztbt03 (character UPLO, character TRANS, character DIAG, integer N, integer KD, integer NRHS, complex*16, dimension( ldab, * ) AB, integer LDAB, double precision SCALE, double precision, dimension( * ) CNORM, double precision TSCAL, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK, double precision RESID)

ZTBT03

Purpose:

 ZTBT03 computes the residual for the solution to a scaled triangular
 system of equations  A*x = s*b,  A**T *x = s*b,  or  A**H *x = s*b
 when A is a triangular band matrix.  Here A**T  denotes the transpose
 of A, A**H denotes the conjugate transpose of A, s is a scalar, and
 x and b are N by NRHS matrices.  The test ratio is the maximum over
 the number of right hand sides of
    norm(s*b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
 where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the operation applied to A.
          = 'N':  A *x = s*b     (No transpose)
          = 'T':  A**T *x = s*b  (Transpose)
          = 'C':  A**H *x = s*b  (Conjugate transpose)


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The order of the matrix A.  N >= 0.


KD

          KD is INTEGER
          The number of superdiagonals or subdiagonals of the
          triangular band matrix A.  KD >= 0.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of columns
          of the matrices X and B.  NRHS >= 0.


AB

          AB is COMPLEX*16 array, dimension (LDAB,N)
          The upper or lower triangular band matrix A, stored in the
          first kd+1 rows of the array. The j-th column of A is stored
          in the j-th column of the array AB as follows:
          if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
          if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).


LDAB

          LDAB is INTEGER
          The leading dimension of the array AB.  LDAB >= KD+1.


SCALE

          SCALE is DOUBLE PRECISION
          The scaling factor s used in solving the triangular system.


CNORM

          CNORM is DOUBLE PRECISION array, dimension (N)
          The 1-norms of the columns of A, not counting the diagonal.


TSCAL

          TSCAL is DOUBLE PRECISION
          The scaling factor used in computing the 1-norms in CNORM.
          CNORM actually contains the column norms of TSCAL*A.


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


WORK

          WORK is COMPLEX*16 array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(op(A)*x - s*b) / ( norm(op(A)) * norm(x) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztbt05 (character UPLO, character TRANS, character DIAG, integer N, integer KD, integer NRHS, complex*16, dimension( ldab, * ) AB, integer LDAB, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)

ZTBT05

Purpose:

 ZTBT05 tests the error bounds from iterative refinement for the
 computed solution to a system of equations A*X = B, where A is a
 triangular band matrix.
 RESLTS(1) = test of the error bound
           = norm(X - XACT) / ( norm(X) * FERR )
 A large value is returned if this ratio is not less than one.
 RESLTS(2) = residual from the iterative refinement routine
           = the maximum of BERR / ( NZ*EPS + (*) ), where
             (*) = NZ*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
             and NZ = max. number of nonzeros in any row of A, plus 1


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the form of the system of equations.
          = 'N':  A * X = B  (No transpose)
          = 'T':  A'* X = B  (Transpose)
          = 'C':  A'* X = B  (Conjugate transpose = Transpose)


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The number of rows of the matrices X, B, and XACT, and the
          order of the matrix A.  N >= 0.


KD

          KD is INTEGER
          The number of super-diagonals of the matrix A if UPLO = 'U',
          or the number of sub-diagonals if UPLO = 'L'.  KD >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of the matrices X, B, and XACT.
          NRHS >= 0.


AB

          AB is COMPLEX*16 array, dimension (LDAB,N)
          The upper or lower triangular band matrix A, stored in the
          first kd+1 rows of the array. The j-th column of A is stored
          in the j-th column of the array AB as follows:
          if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
          if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).
          If DIAG = 'U', the diagonal elements of A are not referenced
          and are assumed to be 1.


LDAB

          LDAB is INTEGER
          The leading dimension of the array AB.  LDAB >= KD+1.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors.  Each vector is stored as a
          column of the matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


XACT

          XACT is COMPLEX*16 array, dimension (LDX,NRHS)
          The exact solution vectors.  Each vector is stored as a
          column of the matrix XACT.


LDXACT

          LDXACT is INTEGER
          The leading dimension of the array XACT.  LDXACT >= max(1,N).


FERR

          FERR is DOUBLE PRECISION array, dimension (NRHS)
          The estimated forward error bounds for each solution vector
          X.  If XTRUE is the true solution, FERR bounds the magnitude
          of the largest entry in (X - XTRUE) divided by the magnitude
          of the largest entry in X.


BERR

          BERR is DOUBLE PRECISION array, dimension (NRHS)
          The componentwise relative backward error of each solution
          vector (i.e., the smallest relative change in any entry of A
          or B that makes X an exact solution).


RESLTS

          RESLTS is DOUBLE PRECISION array, dimension (2)
          The maximum over the NRHS solution vectors of the ratios:
          RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
          RESLTS(2) = BERR / ( NZ*EPS + (*) )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztbt06 (double precision RCOND, double precision RCONDC, character UPLO, character DIAG, integer N, integer KD, complex*16, dimension( ldab, * ) AB, integer LDAB, double precision, dimension( * ) RWORK, double precision RAT)

ZTBT06

Purpose:

 ZTBT06 computes a test ratio comparing RCOND (the reciprocal
 condition number of a triangular matrix A) and RCONDC, the estimate
 computed by ZTBCON.  Information about the triangular matrix A is
 used if one estimate is zero and the other is non-zero to decide if
 underflow in the estimate is justified.


 

Parameters:

RCOND

          RCOND is DOUBLE PRECISION
          The estimate of the reciprocal condition number obtained by
          forming the explicit inverse of the matrix A and computing
          RCOND = 1/( norm(A) * norm(inv(A)) ).


RCONDC

          RCONDC is DOUBLE PRECISION
          The estimate of the reciprocal condition number computed by
          ZTBCON.


UPLO

          UPLO is CHARACTER
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


DIAG

          DIAG is CHARACTER
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The order of the matrix A.  N >= 0.


KD

          KD is INTEGER
          The number of superdiagonals or subdiagonals of the
          triangular band matrix A.  KD >= 0.


AB

          AB is COMPLEX*16 array, dimension (LDAB,N)
          The upper or lower triangular band matrix A, stored in the
          first kd+1 rows of the array. The j-th column of A is stored
          in the j-th column of the array AB as follows:
          if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
          if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).


LDAB

          LDAB is INTEGER
          The leading dimension of the array AB.  LDAB >= KD+1.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RAT

          RAT is DOUBLE PRECISION
          The test ratio.  If both RCOND and RCONDC are nonzero,
             RAT = MAX( RCOND, RCONDC )/MIN( RCOND, RCONDC ) - 1.
          If RAT = 0, the two estimates are exactly the same.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztpt01 (character UPLO, character DIAG, integer N, complex*16, dimension( * ) AP, complex*16, dimension( * ) AINVP, double precision RCOND, double precision, dimension( * ) RWORK, double precision RESID)

ZTPT01

Purpose:

 ZTPT01 computes the residual for a triangular matrix A times its
 inverse when A is stored in packed format:
    RESID = norm(A*AINV - I) / ( N * norm(A) * norm(AINV) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The order of the matrix A.  N >= 0.


AP

          AP is COMPLEX*16 array, dimension (N*(N+1)/2)
          The original upper or lower triangular matrix A, packed
          columnwise in a linear array.  The j-th column of A is stored
          in the array AP as follows:
          if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
          if UPLO = 'L',
             AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.


AINVP

          AINVP is COMPLEX*16 array, dimension (N*(N+1)/2)
          On entry, the (triangular) inverse of the matrix A, packed
          columnwise in a linear array as in AP.
          On exit, the contents of AINVP are destroyed.


RCOND

          RCOND is DOUBLE PRECISION
          The reciprocal condition number of A, computed as
          1/(norm(A) * norm(AINV)).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          norm(A*AINV - I) / ( N * norm(A) * norm(AINV) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztpt02 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS, complex*16, dimension( * ) AP, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, double precision RESID)

ZTPT02

Purpose:

 ZTPT02 computes the residual for the computed solution to a
 triangular system of linear equations  A*x = b,  A**T *x = b,  or
 A**H *x = b, when the triangular matrix A is stored in packed format.
 Here A**T denotes the transpose of A, A**H denotes the conjugate
 transpose of A, and x and b are N by NRHS matrices.  The test ratio
 is the maximum over the number of right hand sides of
 the maximum over the number of right hand sides of
    norm(b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
 where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the operation applied to A.
          = 'N':  A *x = b     (No transpose)
          = 'T':  A**T *x = b  (Transpose)
          = 'C':  A**H *x = b  (Conjugate transpose)


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The order of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of columns
          of the matrices X and B.  NRHS >= 0.


AP

          AP is COMPLEX*16 array, dimension (N*(N+1)/2)
          The upper or lower triangular matrix A, packed columnwise in
          a linear array.  The j-th column of A is stored in the array
          AP as follows:
          if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
          if UPLO = 'L',
             AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


WORK

          WORK is COMPLEX*16 array, dimension (N)


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(op(A)*x - b) / ( norm(op(A)) * norm(x) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztpt03 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS, complex*16, dimension( * ) AP, double precision SCALE, double precision, dimension( * ) CNORM, double precision TSCAL, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK, double precision RESID)

ZTPT03

Purpose:

 ZTPT03 computes the residual for the solution to a scaled triangular
 system of equations A*x = s*b,  A**T *x = s*b,  or  A**H *x = s*b,
 when the triangular matrix A is stored in packed format.  Here A**T
 denotes the transpose of A, A**H denotes the conjugate transpose of
 A, s is a scalar, and x and b are N by NRHS matrices.  The test ratio
 is the maximum over the number of right hand sides of
    norm(s*b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
 where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the operation applied to A.
          = 'N':  A *x = s*b     (No transpose)
          = 'T':  A**T *x = s*b  (Transpose)
          = 'C':  A**H *x = s*b  (Conjugate transpose)


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The order of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of columns
          of the matrices X and B.  NRHS >= 0.


AP

          AP is COMPLEX*16 array, dimension (N*(N+1)/2)
          The upper or lower triangular matrix A, packed columnwise in
          a linear array.  The j-th column of A is stored in the array
          AP as follows:
          if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
          if UPLO = 'L',
             AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.


SCALE

          SCALE is DOUBLE PRECISION
          The scaling factor s used in solving the triangular system.


CNORM

          CNORM is DOUBLE PRECISION array, dimension (N)
          The 1-norms of the columns of A, not counting the diagonal.


TSCAL

          TSCAL is DOUBLE PRECISION
          The scaling factor used in computing the 1-norms in CNORM.
          CNORM actually contains the column norms of TSCAL*A.


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


WORK

          WORK is COMPLEX*16 array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(op(A)*x - s*b) / ( norm(op(A)) * norm(x) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztpt05 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS, complex*16, dimension( * ) AP, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)

ZTPT05

Purpose:

 ZTPT05 tests the error bounds from iterative refinement for the
 computed solution to a system of equations A*X = B, where A is a
 triangular matrix in packed storage format.
 RESLTS(1) = test of the error bound
           = norm(X - XACT) / ( norm(X) * FERR )
 A large value is returned if this ratio is not less than one.
 RESLTS(2) = residual from the iterative refinement routine
           = the maximum of BERR / ( (n+1)*EPS + (*) ), where
             (*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the form of the system of equations.
          = 'N':  A * X = B  (No transpose)
          = 'T':  A'* X = B  (Transpose)
          = 'C':  A'* X = B  (Conjugate transpose = Transpose)


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The number of rows of the matrices X, B, and XACT, and the
          order of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of the matrices X, B, and XACT.
          NRHS >= 0.


AP

          AP is COMPLEX*16 array, dimension (N*(N+1)/2)
          The upper or lower triangular matrix A, packed columnwise in
          a linear array.  The j-th column of A is stored in the array
          AP as follows:
          if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
          if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
          If DIAG = 'U', the diagonal elements of A are not referenced
          and are assumed to be 1.


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors.  Each vector is stored as a
          column of the matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


XACT

          XACT is COMPLEX*16 array, dimension (LDX,NRHS)
          The exact solution vectors.  Each vector is stored as a
          column of the matrix XACT.


LDXACT

          LDXACT is INTEGER
          The leading dimension of the array XACT.  LDXACT >= max(1,N).


FERR

          FERR is DOUBLE PRECISION array, dimension (NRHS)
          The estimated forward error bounds for each solution vector
          X.  If XTRUE is the true solution, FERR bounds the magnitude
          of the largest entry in (X - XTRUE) divided by the magnitude
          of the largest entry in X.


BERR

          BERR is DOUBLE PRECISION array, dimension (NRHS)
          The componentwise relative backward error of each solution
          vector (i.e., the smallest relative change in any entry of A
          or B that makes X an exact solution).


RESLTS

          RESLTS is DOUBLE PRECISION array, dimension (2)
          The maximum over the NRHS solution vectors of the ratios:
          RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
          RESLTS(2) = BERR / ( (n+1)*EPS + (*) )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztpt06 (double precision RCOND, double precision RCONDC, character UPLO, character DIAG, integer N, complex*16, dimension( * ) AP, double precision, dimension( * ) RWORK, double precision RAT)

ZTPT06

Purpose:

 ZTPT06 computes a test ratio comparing RCOND (the reciprocal
 condition number of the triangular matrix A) and RCONDC, the estimate
 computed by ZTPCON.  Information about the triangular matrix is used
 if one estimate is zero and the other is non-zero to decide if
 underflow in the estimate is justified.


 

Parameters:

RCOND

          RCOND is DOUBLE PRECISION
          The estimate of the reciprocal condition number obtained by
          forming the explicit inverse of the matrix A and computing
          RCOND = 1/( norm(A) * norm(inv(A)) ).


RCONDC

          RCONDC is DOUBLE PRECISION
          The estimate of the reciprocal condition number computed by
          ZTPCON.


UPLO

          UPLO is CHARACTER
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


DIAG

          DIAG is CHARACTER
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The order of the matrix A.  N >= 0.


AP

          AP is COMPLEX*16 array, dimension (N*(N+1)/2)
          The upper or lower triangular matrix A, packed columnwise in
          a linear array.  The j-th column of A is stored in the array
          AP as follows:
          if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
          if UPLO = 'L',
             AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RAT

          RAT is DOUBLE PRECISION
          The test ratio.  If both RCOND and RCONDC are nonzero,
             RAT = MAX( RCOND, RCONDC )/MIN( RCOND, RCONDC ) - 1.
          If RAT = 0, the two estimates are exactly the same.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztrt01 (character UPLO, character DIAG, integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldainv, * ) AINV, integer LDAINV, double precision RCOND, double precision, dimension( * ) RWORK, double precision RESID)

ZTRT01

Purpose:

 ZTRT01 computes the residual for a triangular matrix A times its
 inverse:
    RESID = norm( A*AINV - I ) / ( N * norm(A) * norm(AINV) * EPS ),
 where EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The order of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The triangular matrix A.  If UPLO = 'U', the leading n by n
          upper triangular part of the array A contains the upper
          triangular matrix, and the strictly lower triangular part of
          A is not referenced.  If UPLO = 'L', the leading n by n lower
          triangular part of the array A contains the lower triangular
          matrix, and the strictly upper triangular part of A is not
          referenced.  If DIAG = 'U', the diagonal elements of A are
          also not referenced and are assumed to be 1.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


AINV

          AINV is COMPLEX*16 array, dimension (LDAINV,N)
          On entry, the (triangular) inverse of the matrix A, in the
          same storage format as A.
          On exit, the contents of AINV are destroyed.


LDAINV

          LDAINV is INTEGER
          The leading dimension of the array AINV.  LDAINV >= max(1,N).


RCOND

          RCOND is DOUBLE PRECISION
          The reciprocal condition number of A, computed as
          1/(norm(A) * norm(AINV)).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          norm(A*AINV - I) / ( N * norm(A) * norm(AINV) * EPS )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztrt02 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, double precision RESID)

ZTRT02

Purpose:

 ZTRT02 computes the residual for the computed solution to a
 triangular system of linear equations  A*x = b,  A**T *x = b,
 or A**H *x = b.  Here A is a triangular matrix, A**T is the transpose
 of A, A**H is the conjugate transpose of A, and x and b are N by NRHS
 matrices.  The test ratio is the maximum over the number of right
 hand sides of
    norm(b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
 where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the operation applied to A.
          = 'N':  A *x = b     (No transpose)
          = 'T':  A**T *x = b  (Transpose)
          = 'C':  A**H *x = b  (Conjugate transpose)


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The order of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of columns
          of the matrices X and B.  NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The triangular matrix A.  If UPLO = 'U', the leading n by n
          upper triangular part of the array A contains the upper
          triangular matrix, and the strictly lower triangular part of
          A is not referenced.  If UPLO = 'L', the leading n by n lower
          triangular part of the array A contains the lower triangular
          matrix, and the strictly upper triangular part of A is not
          referenced.  If DIAG = 'U', the diagonal elements of A are
          also not referenced and are assumed to be 1.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


WORK

          WORK is COMPLEX*16 array, dimension (N)


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(op(A)*x - b) / ( norm(op(A)) * norm(x) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztrt03 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, double precision SCALE, double precision, dimension( * ) CNORM, double precision TSCAL, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK, double precision RESID)

ZTRT03

Purpose:

 ZTRT03 computes the residual for the solution to a scaled triangular
 system of equations A*x = s*b,  A**T *x = s*b,  or  A**H *x = s*b.
 Here A is a triangular matrix, A**T denotes the transpose of A, A**H
 denotes the conjugate transpose of A, s is a scalar, and x and b are
 N by NRHS matrices.  The test ratio is the maximum over the number of
 right hand sides of
    norm(s*b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
 where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the operation applied to A.
          = 'N':  A *x = s*b     (No transpose)
          = 'T':  A**T *x = s*b  (Transpose)
          = 'C':  A**H *x = s*b  (Conjugate transpose)


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The order of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of right hand sides, i.e., the number of columns
          of the matrices X and B.  NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The triangular matrix A.  If UPLO = 'U', the leading n by n
          upper triangular part of the array A contains the upper
          triangular matrix, and the strictly lower triangular part of
          A is not referenced.  If UPLO = 'L', the leading n by n lower
          triangular part of the array A contains the lower triangular
          matrix, and the strictly upper triangular part of A is not
          referenced.  If DIAG = 'U', the diagonal elements of A are
          also not referenced and are assumed to be 1.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


SCALE

          SCALE is DOUBLE PRECISION
          The scaling factor s used in solving the triangular system.


CNORM

          CNORM is DOUBLE PRECISION array, dimension (N)
          The 1-norms of the columns of A, not counting the diagonal.


TSCAL

          TSCAL is DOUBLE PRECISION
          The scaling factor used in computing the 1-norms in CNORM.
          CNORM actually contains the column norms of TSCAL*A.


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors for the system of linear
          equations.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


WORK

          WORK is COMPLEX*16 array, dimension (N)


RESID

          RESID is DOUBLE PRECISION
          The maximum over the number of right hand sides of
          norm(op(A)*x - s*b) / ( norm(op(A)) * norm(x) * EPS ).


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztrt05 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)

ZTRT05

Purpose:

 ZTRT05 tests the error bounds from iterative refinement for the
 computed solution to a system of equations A*X = B, where A is a
 triangular n by n matrix.
 RESLTS(1) = test of the error bound
           = norm(X - XACT) / ( norm(X) * FERR )
 A large value is returned if this ratio is not less than one.
 RESLTS(2) = residual from the iterative refinement routine
           = the maximum of BERR / ( (n+1)*EPS + (*) ), where
             (*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )


 

Parameters:

UPLO

          UPLO is CHARACTER*1
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


TRANS

          TRANS is CHARACTER*1
          Specifies the form of the system of equations.
          = 'N':  A * X = B  (No transpose)
          = 'T':  A'* X = B  (Transpose)
          = 'C':  A'* X = B  (Conjugate transpose = Transpose)


DIAG

          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The number of rows of the matrices X, B, and XACT, and the
          order of the matrix A.  N >= 0.


NRHS

          NRHS is INTEGER
          The number of columns of the matrices X, B, and XACT.
          NRHS >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The triangular matrix A.  If UPLO = 'U', the leading n by n
          upper triangular part of the array A contains the upper
          triangular matrix, and the strictly lower triangular part of
          A is not referenced.  If UPLO = 'L', the leading n by n lower
          triangular part of the array A contains the lower triangular
          matrix, and the strictly upper triangular part of A is not
          referenced.  If DIAG = 'U', the diagonal elements of A are
          also not referenced and are assumed to be 1.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


B

          B is COMPLEX*16 array, dimension (LDB,NRHS)
          The right hand side vectors for the system of linear
          equations.


LDB

          LDB is INTEGER
          The leading dimension of the array B.  LDB >= max(1,N).


X

          X is COMPLEX*16 array, dimension (LDX,NRHS)
          The computed solution vectors.  Each vector is stored as a
          column of the matrix X.


LDX

          LDX is INTEGER
          The leading dimension of the array X.  LDX >= max(1,N).


XACT

          XACT is COMPLEX*16 array, dimension (LDX,NRHS)
          The exact solution vectors.  Each vector is stored as a
          column of the matrix XACT.


LDXACT

          LDXACT is INTEGER
          The leading dimension of the array XACT.  LDXACT >= max(1,N).


FERR

          FERR is DOUBLE PRECISION array, dimension (NRHS)
          The estimated forward error bounds for each solution vector
          X.  If XTRUE is the true solution, FERR bounds the magnitude
          of the largest entry in (X - XTRUE) divided by the magnitude
          of the largest entry in X.


BERR

          BERR is DOUBLE PRECISION array, dimension (NRHS)
          The componentwise relative backward error of each solution
          vector (i.e., the smallest relative change in any entry of A
          or B that makes X an exact solution).


RESLTS

          RESLTS is DOUBLE PRECISION array, dimension (2)
          The maximum over the NRHS solution vectors of the ratios:
          RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
          RESLTS(2) = BERR / ( (n+1)*EPS + (*) )


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

subroutine ztrt06 (double precision RCOND, double precision RCONDC, character UPLO, character DIAG, integer N, complex*16, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) RWORK, double precision RAT)

ZTRT06

Purpose:

 ZTRT06 computes a test ratio comparing RCOND (the reciprocal
 condition number of a triangular matrix A) and RCONDC, the estimate
 computed by ZTRCON.  Information about the triangular matrix A is
 used if one estimate is zero and the other is non-zero to decide if
 underflow in the estimate is justified.


 

Parameters:

RCOND

          RCOND is DOUBLE PRECISION
          The estimate of the reciprocal condition number obtained by
          forming the explicit inverse of the matrix A and computing
          RCOND = 1/( norm(A) * norm(inv(A)) ).


RCONDC

          RCONDC is DOUBLE PRECISION
          The estimate of the reciprocal condition number computed by
          ZTRCON.


UPLO

          UPLO is CHARACTER
          Specifies whether the matrix A is upper or lower triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular


DIAG

          DIAG is CHARACTER
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular


N

          N is INTEGER
          The order of the matrix A.  N >= 0.


A

          A is COMPLEX*16 array, dimension (LDA,N)
          The triangular matrix A.  If UPLO = 'U', the leading n by n
          upper triangular part of the array A contains the upper
          triangular matrix, and the strictly lower triangular part of
          A is not referenced.  If UPLO = 'L', the leading n by n lower
          triangular part of the array A contains the lower triangular
          matrix, and the strictly upper triangular part of A is not
          referenced.  If DIAG = 'U', the diagonal elements of A are
          also not referenced and are assumed to be 1.


LDA

          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).


RWORK

          RWORK is DOUBLE PRECISION array, dimension (N)


RAT

          RAT is DOUBLE PRECISION
          The test ratio.  If both RCOND and RCONDC are nonzero,
             RAT = MAX( RCOND, RCONDC )/MIN( RCOND, RCONDC ) - 1.
          If RAT = 0, the two estimates are exactly the same.


 

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Author

Generated automatically by Doxygen for LAPACK from the source code.