Provided by: liblapack-doc-man_3.6.0-2ubuntu2_all 
NAME
complex16_lin - complex16
Functions
program zchkaa
ZCHKAA
program zchkab
ZCHKAB
subroutine zchkeq (THRESH, NOUT)
ZCHKEQ
subroutine zchkgb (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, A,
LA, AFAC, LAFAC, B, X, XACT, WORK, RWORK, IWORK, NOUT)
ZCHKGB
subroutine zchkge (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR,
NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
ZCHKGE
subroutine zchkgt (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, AF, B, X, XACT, WORK,
RWORK, IWORK, NOUT)
ZCHKGT
subroutine zchkhe (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
ZCHKHE
subroutine zchkhe_rook (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
ZCHKHE_ROOK
subroutine zchkhp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B,
X, XACT, WORK, RWORK, IWORK, NOUT)
ZCHKHP
subroutine zchklq (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR,
NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, NOUT)
ZCHKLQ
subroutine zchkpb (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
AFAC, AINV, B, X, XACT, WORK, RWORK, NOUT)
ZCHKPB
subroutine zchkpo (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
AFAC, AINV, B, X, XACT, WORK, RWORK, NOUT)
ZCHKPO
subroutine zchkpp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B,
X, XACT, WORK, RWORK, NOUT)
ZCHKPP
subroutine zchkps (DOTYPE, NN, NVAL, NNB, NBVAL, NRANK, RANKVAL, THRESH, TSTERR, NMAX, A,
AFAC, PERM, PIV, WORK, RWORK, NOUT)
ZCHKPS
subroutine zchkpt (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, D, E, B, X, XACT,
WORK, RWORK, NOUT)
ZCHKPT
subroutine zchkq3 (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, THRESH, A, COPYA, S,
TAU, WORK, RWORK, IWORK, NOUT)
ZCHKQ3
subroutine zchkql (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR,
NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, NOUT)
ZCHKQL
subroutine zchkqr (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR,
NMAX, A, AF, AQ, AR, AC, B, X, XACT, TAU, WORK, RWORK, IWORK, NOUT)
ZCHKQR
subroutine zchkqrt (THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
ZCHKQRT
subroutine zchkqrtp (THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT)
ZCHKQRTP
program zchkrfp
ZCHKRFP
subroutine zchkrq (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR,
NMAX, A, AF, AQ, AR, AC, B, X, XACT, TAU, WORK, RWORK, IWORK, NOUT)
ZCHKRQ
subroutine zchksp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B,
X, XACT, WORK, RWORK, IWORK, NOUT)
ZCHKSP
subroutine zchksy (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
ZCHKSY
subroutine zchksy_rook (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT)
ZCHKSY_ROOK
subroutine zchktb (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AB, AINV, B, X,
XACT, WORK, RWORK, NOUT)
ZCHKTB
subroutine zchktp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AP, AINVP, B, X,
XACT, WORK, RWORK, NOUT)
ZCHKTP
subroutine zchktr (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A,
AINV, B, X, XACT, WORK, RWORK, NOUT)
ZCHKTR
subroutine zchktz (DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR, A, COPYA, S, TAU, WORK,
RWORK, NOUT)
ZCHKTZ
subroutine zdrvab (DOTYPE, NM, MVAL, NNS, NSVAL, THRESH, NMAX, A, AFAC, B, X, WORK, RWORK,
SWORK, IWORK, NOUT)
ZDRVAB
subroutine zdrvac (DOTYPE, NM, MVAL, NNS, NSVAL, THRESH, NMAX, A, AFAC, B, X, WORK, RWORK,
SWORK, NOUT)
ZDRVAC
subroutine zdrvgb (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, LA, AFB, LAFB, ASAV, B,
BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT)
ZDRVGB
subroutine zdrvge (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV,
X, XACT, S, WORK, RWORK, IWORK, NOUT)
ZDRVGE
subroutine zdrvgt (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK,
IWORK, NOUT)
ZDRVGT
subroutine zdrvhe (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
XACT, WORK, RWORK, IWORK, NOUT)
ZDRVHE
subroutine zdrvhe_rook (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
XACT, WORK, RWORK, IWORK, NOUT)
ZDRVHE_ROOK
subroutine zdrvhp (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
XACT, WORK, RWORK, IWORK, NOUT)
ZDRVHP
subroutine zdrvls (DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB, NBVAL, NXVAL, THRESH,
TSTERR, A, COPYA, B, COPYB, C, S, COPYS, WORK, RWORK, IWORK, NOUT)
ZDRVLS
subroutine zdrvpb (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV,
X, XACT, S, WORK, RWORK, NOUT)
ZDRVPB
subroutine zdrvpo (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV,
X, XACT, S, WORK, RWORK, NOUT)
ZDRVPO
subroutine zdrvpp (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV,
X, XACT, S, WORK, RWORK, NOUT)
ZDRVPP
subroutine zdrvpt (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, D, E, B, X, XACT, WORK,
RWORK, NOUT)
ZDRVPT
subroutine zdrvrf1 (NOUT, NN, NVAL, THRESH, A, LDA, ARF, WORK)
ZDRVRF1
subroutine zdrvrf2 (NOUT, NN, NVAL, A, LDA, ARF, AP, ASAV)
ZDRVRF2
subroutine zdrvrf3 (NOUT, NN, NVAL, THRESH, A, LDA, ARF, B1, B2, D_WORK_ZLANGE,
Z_WORK_ZGEQRF, TAU)
ZDRVRF3
subroutine zdrvrf4 (NOUT, NN, NVAL, THRESH, C1, C2, LDC, CRF, A, LDA, D_WORK_ZLANGE)
ZDRVRF4
subroutine zdrvrfp (NOUT, NN, NVAL, NNS, NSVAL, NNT, NTVAL, THRESH, A, ASAV, AFAC, AINV,
B, BSAV, XACT, X, ARF, ARFINV, Z_WORK_ZLATMS, Z_WORK_ZPOT02, Z_WORK_ZPOT03,
D_WORK_ZLATMS, D_WORK_ZLANHE, D_WORK_ZPOT01, D_WORK_ZPOT02, D_WORK_ZPOT03)
ZDRVRFP
subroutine zdrvsp (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
XACT, WORK, RWORK, IWORK, NOUT)
ZDRVSP
subroutine zdrvsy (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
XACT, WORK, RWORK, IWORK, NOUT)
ZDRVSY
subroutine zdrvsy_rook (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X,
XACT, WORK, RWORK, IWORK, NOUT)
ZDRVSY_ROOK
subroutine zebchvxx (THRESH, PATH)
ZEBCHVXX
subroutine zerrab (NUNIT)
ZERRAB
subroutine zerrac (NUNIT)
ZERRAC
subroutine zerrge (PATH, NUNIT)
ZERRGE
subroutine zerrgt (PATH, NUNIT)
ZERRGT
subroutine zerrhe (PATH, NUNIT)
ZERRHE
subroutine zerrlq (PATH, NUNIT)
ZERRLQ
subroutine zerrls (PATH, NUNIT)
ZERRLS
subroutine zerrpo (PATH, NUNIT)
ZERRPO
subroutine zerrps (PATH, NUNIT)
ZERRPS
subroutine zerrql (PATH, NUNIT)
ZERRQL
subroutine zerrqp (PATH, NUNIT)
ZERRQP
subroutine zerrqr (PATH, NUNIT)
ZERRQR
subroutine zerrqrt (PATH, NUNIT)
ZERRQRT
subroutine zerrqrtp (PATH, NUNIT)
ZERRQRTP
subroutine zerrrfp (NUNIT)
ZERRRFP
subroutine zerrrq (PATH, NUNIT)
ZERRRQ
subroutine zerrsy (PATH, NUNIT)
ZERRSY
subroutine zerrtr (PATH, NUNIT)
ZERRTR
subroutine zerrtz (PATH, NUNIT)
ZERRTZ
subroutine zerrvx (PATH, NUNIT)
ZERRVX
subroutine zgbt01 (M, N, KL, KU, A, LDA, AFAC, LDAFAC, IPIV, WORK, RESID)
ZGBT01
subroutine zgbt02 (TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, RESID)
ZGBT02
subroutine zgbt05 (TRANS, N, KL, KU, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR,
BERR, RESLTS)
ZGBT05
subroutine zgelqs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO)
ZGELQS
logical function zgennd (M, N, A, LDA)
ZGENND
subroutine zgeqls (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO)
ZGEQLS
subroutine zgeqrs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO)
ZGEQRS
subroutine zgerqs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO)
ZGERQS
subroutine zget01 (M, N, A, LDA, AFAC, LDAFAC, IPIV, RWORK, RESID)
ZGET01
subroutine zget02 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZGET02
subroutine zget03 (N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID)
ZGET03
subroutine zget04 (N, NRHS, X, LDX, XACT, LDXACT, RCOND, RESID)
ZGET04
subroutine zget07 (TRANS, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, CHKFERR,
BERR, RESLTS)
ZGET07
subroutine zget08 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZGET08
subroutine zgtt01 (N, DL, D, DU, DLF, DF, DUF, DU2, IPIV, WORK, LDWORK, RWORK, RESID)
ZGTT01
subroutine zgtt02 (TRANS, N, NRHS, DL, D, DU, X, LDX, B, LDB, RESID)
ZGTT02
subroutine zgtt05 (TRANS, N, NRHS, DL, D, DU, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR,
RESLTS)
ZGTT05
subroutine zhet01 (UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
ZHET01
subroutine zhet01_rook (UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
ZHET01_ROOK
subroutine zhpt01 (UPLO, N, A, AFAC, IPIV, C, LDC, RWORK, RESID)
ZHPT01
subroutine zlahilb (N, NRHS, A, LDA, X, LDX, B, LDB, WORK, INFO, PATH)
ZLAHILB
subroutine zlaipd (N, A, INDA, VINDA)
ZLAIPD
subroutine zlaptm (UPLO, N, NRHS, ALPHA, D, E, X, LDX, BETA, B, LDB)
ZLAPTM
subroutine zlarhs (PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB,
ISEED, INFO)
ZLARHS
subroutine zlatb4 (PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST)
ZLATB4
subroutine zlatb5 (PATH, IMAT, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST)
ZLATB5
subroutine zlatsp (UPLO, N, X, ISEED)
ZLATSP
subroutine zlatsy (UPLO, N, X, LDX, ISEED)
ZLATSY
subroutine zlattb (IMAT, UPLO, TRANS, DIAG, ISEED, N, KD, AB, LDAB, B, WORK, RWORK, INFO)
ZLATTB
subroutine zlattp (IMAT, UPLO, TRANS, DIAG, ISEED, N, AP, B, WORK, RWORK, INFO)
ZLATTP
subroutine zlattr (IMAT, UPLO, TRANS, DIAG, ISEED, N, A, LDA, B, WORK, RWORK, INFO)
ZLATTR
subroutine zlavhe (UPLO, TRANS, DIAG, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
ZLAVHE
subroutine zlavhe_rook (UPLO, TRANS, DIAG, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
ZLAVHE_ROOK
subroutine zlavhp (UPLO, TRANS, DIAG, N, NRHS, A, IPIV, B, LDB, INFO)
ZLAVHP
subroutine zlavsp (UPLO, TRANS, DIAG, N, NRHS, A, IPIV, B, LDB, INFO)
ZLAVSP
subroutine zlavsy (UPLO, TRANS, DIAG, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
ZLAVSY
subroutine zlavsy_rook (UPLO, TRANS, DIAG, N, NRHS, A, LDA, IPIV, B, LDB, INFO)
ZLAVSY_ROOK
subroutine zlqt01 (M, N, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT)
ZLQT01
subroutine zlqt02 (M, N, K, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT)
ZLQT02
subroutine zlqt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT)
ZLQT03
subroutine zpbt01 (UPLO, N, KD, A, LDA, AFAC, LDAFAC, RWORK, RESID)
ZPBT01
subroutine zpbt02 (UPLO, N, KD, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZPBT02
subroutine zpbt05 (UPLO, N, KD, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR,
RESLTS)
ZPBT05
subroutine zpot01 (UPLO, N, A, LDA, AFAC, LDAFAC, RWORK, RESID)
ZPOT01
subroutine zpot02 (UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZPOT02
subroutine zpot03 (UPLO, N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID)
ZPOT03
subroutine zpot05 (UPLO, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR,
RESLTS)
ZPOT05
subroutine zpot06 (UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZPOT06
subroutine zppt01 (UPLO, N, A, AFAC, RWORK, RESID)
ZPPT01
subroutine zppt02 (UPLO, N, NRHS, A, X, LDX, B, LDB, RWORK, RESID)
ZPPT02
subroutine zppt03 (UPLO, N, A, AINV, WORK, LDWORK, RWORK, RCOND, RESID)
ZPPT03
subroutine zppt05 (UPLO, N, NRHS, AP, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS)
ZPPT05
subroutine zpst01 (UPLO, N, A, LDA, AFAC, LDAFAC, PERM, LDPERM, PIV, RWORK, RESID, RANK)
ZPST01
subroutine zptt01 (N, D, E, DF, EF, WORK, RESID)
ZPTT01
subroutine zptt02 (UPLO, N, NRHS, D, E, X, LDX, B, LDB, RESID)
ZPTT02
subroutine zptt05 (N, NRHS, D, E, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS)
ZPTT05
subroutine zqlt01 (M, N, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT)
ZQLT01
subroutine zqlt02 (M, N, K, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT)
ZQLT02
subroutine zqlt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT)
ZQLT03
double precision function zqpt01 (M, N, K, A, AF, LDA, TAU, JPVT, WORK, LWORK)
ZQPT01
subroutine zqrt01 (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT)
ZQRT01
subroutine zqrt01p (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT)
ZQRT01P
subroutine zqrt02 (M, N, K, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT)
ZQRT02
subroutine zqrt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT)
ZQRT03
subroutine zqrt04 (M, N, NB, RESULT)
ZQRT04
subroutine zqrt05 (M, N, L, NB, RESULT)
ZQRT05
double precision function zqrt11 (M, K, A, LDA, TAU, WORK, LWORK)
ZQRT11
double precision function zqrt12 (M, N, A, LDA, S, WORK, LWORK, RWORK)
ZQRT12
subroutine zqrt13 (SCALE, M, N, A, LDA, NORMA, ISEED)
ZQRT13
double precision function zqrt14 (TRANS, M, N, NRHS, A, LDA, X, LDX, WORK, LWORK)
ZQRT14
subroutine zqrt15 (SCALE, RKSEL, M, N, NRHS, A, LDA, B, LDB, S, RANK, NORMA, NORMB, ISEED,
WORK, LWORK)
ZQRT15
subroutine zqrt16 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZQRT16
double precision function zqrt17 (TRANS, IRESID, M, N, NRHS, A, LDA, X, LDX, B, LDB, C,
WORK, LWORK)
ZQRT17
subroutine zrqt01 (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT)
ZRQT01
subroutine zrqt02 (M, N, K, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT)
ZRQT02
subroutine zrqt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT)
ZRQT03
double precision function zrzt01 (M, N, A, AF, LDA, TAU, WORK, LWORK)
ZRZT01
double precision function zrzt02 (M, N, AF, LDA, TAU, WORK, LWORK)
ZRZT02
subroutine zsbmv (UPLO, N, K, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)
ZSBMV
subroutine zspt01 (UPLO, N, A, AFAC, IPIV, C, LDC, RWORK, RESID)
ZSPT01
subroutine zspt02 (UPLO, N, NRHS, A, X, LDX, B, LDB, RWORK, RESID)
ZSPT02
subroutine zspt03 (UPLO, N, A, AINV, WORK, LDW, RWORK, RCOND, RESID)
ZSPT03
subroutine zsyt01 (UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
ZSYT01
subroutine zsyt01_rook (UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID)
ZSYT01_ROOK
subroutine zsyt02 (UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
ZSYT02
subroutine zsyt03 (UPLO, N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID)
ZSYT03
subroutine ztbt02 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, X, LDX, B, LDB, WORK, RWORK,
RESID)
ZTBT02
subroutine ztbt03 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, SCALE, CNORM, TSCAL, X, LDX,
B, LDB, WORK, RESID)
ZTBT03
subroutine ztbt05 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT,
FERR, BERR, RESLTS)
ZTBT05
subroutine ztbt06 (RCOND, RCONDC, UPLO, DIAG, N, KD, AB, LDAB, RWORK, RAT)
ZTBT06
subroutine ztpt01 (UPLO, DIAG, N, AP, AINVP, RCOND, RWORK, RESID)
ZTPT01
subroutine ztpt02 (UPLO, TRANS, DIAG, N, NRHS, AP, X, LDX, B, LDB, WORK, RWORK, RESID)
ZTPT02
subroutine ztpt03 (UPLO, TRANS, DIAG, N, NRHS, AP, SCALE, CNORM, TSCAL, X, LDX, B, LDB,
WORK, RESID)
ZTPT03
subroutine ztpt05 (UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, X, LDX, XACT, LDXACT, FERR,
BERR, RESLTS)
ZTPT05
subroutine ztpt06 (RCOND, RCONDC, UPLO, DIAG, N, AP, RWORK, RAT)
ZTPT06
subroutine ztrt01 (UPLO, DIAG, N, A, LDA, AINV, LDAINV, RCOND, RWORK, RESID)
ZTRT01
subroutine ztrt02 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, X, LDX, B, LDB, WORK, RWORK, RESID)
ZTRT02
subroutine ztrt03 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, SCALE, CNORM, TSCAL, X, LDX, B,
LDB, WORK, RESID)
ZTRT03
subroutine ztrt05 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR,
BERR, RESLTS)
ZTRT05
subroutine ztrt06 (RCOND, RCONDC, UPLO, DIAG, N, A, LDA, RWORK, RAT)
ZTRT06
Detailed Description
This is the group of complex16 LAPACK TESTING LIN routines.
Function Documentation
program zchkaa ()
ZCHKAA
Purpose:
ZCHKAA is the main test program for the COMPLEX*16 linear equation
routines.
The program must be driven by a short data file. The first 15 records
(not including the first comment line) specify problem dimensions
and program options using list-directed input. The remaining lines
specify the LAPACK test paths and the number of matrix types to use
in testing. An annotated example of a data file can be obtained by
deleting the first 3 characters from the following 42 lines:
Data file for testing COMPLEX*16 LAPACK linear equation routines
7 Number of values of M
0 1 2 3 5 10 16 Values of M (row dimension)
7 Number of values of N
0 1 2 3 5 10 16 Values of N (column dimension)
1 Number of values of NRHS
2 Values of NRHS (number of right hand sides)
5 Number of values of NB
1 3 3 3 20 Values of NB (the blocksize)
1 0 5 9 1 Values of NX (crossover point)
3 Number of values of RANK
30 50 90 Values of rank (as a % of N)
30.0 Threshold value of test ratio
T Put T to test the LAPACK routines
T Put T to test the driver routines
T Put T to test the error exits
ZGE 11 List types on next line if 0 < NTYPES < 11
ZGB 8 List types on next line if 0 < NTYPES < 8
ZGT 12 List types on next line if 0 < NTYPES < 12
ZPO 9 List types on next line if 0 < NTYPES < 9
ZPS 9 List types on next line if 0 < NTYPES < 9
ZPP 9 List types on next line if 0 < NTYPES < 9
ZPB 8 List types on next line if 0 < NTYPES < 8
ZPT 12 List types on next line if 0 < NTYPES < 12
ZHE 10 List types on next line if 0 < NTYPES < 10
ZHR 10 List types on next line if 0 < NTYPES < 10
ZHP 10 List types on next line if 0 < NTYPES < 10
ZSY 11 List types on next line if 0 < NTYPES < 11
ZSR 11 List types on next line if 0 < NTYPES < 11
ZSP 11 List types on next line if 0 < NTYPES < 11
ZTR 18 List types on next line if 0 < NTYPES < 18
ZTP 18 List types on next line if 0 < NTYPES < 18
ZTB 17 List types on next line if 0 < NTYPES < 17
ZQR 8 List types on next line if 0 < NTYPES < 8
ZRQ 8 List types on next line if 0 < NTYPES < 8
ZLQ 8 List types on next line if 0 < NTYPES < 8
ZQL 8 List types on next line if 0 < NTYPES < 8
ZQP 6 List types on next line if 0 < NTYPES < 6
ZTZ 3 List types on next line if 0 < NTYPES < 3
ZLS 6 List types on next line if 0 < NTYPES < 6
ZEQ
ZQT
ZQX
NMAX INTEGER
The maximum allowable value for M and N.
MAXIN INTEGER
The number of different values that can be used for each of
M, N, NRHS, NB, NX and RANK
MAXRHS INTEGER
The maximum number of right hand sides
MATMAX INTEGER
The maximum number of matrix types to use for testing
NIN INTEGER
The unit number for input
NOUT INTEGER
The unit number for output
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
program zchkab ()
ZCHKAB
Purpose:
ZCHKAB is the test program for the COMPLEX*16 LAPACK
ZCGESV/ZCPOSV routine
The program must be driven by a short data file. The first 5 records
specify problem dimensions and program options using list-directed
input. The remaining lines specify the LAPACK test paths and the
number of matrix types to use in testing. An annotated example of a
data file can be obtained by deleting the first 3 characters from the
following 9 lines:
Data file for testing COMPLEX*16 LAPACK ZCGESV
7 Number of values of M
0 1 2 3 5 10 16 Values of M (row dimension)
1 Number of values of NRHS
2 Values of NRHS (number of right hand sides)
20.0 Threshold value of test ratio
T Put T to test the LAPACK routine
T Put T to test the error exits
DGE 11 List types on next line if 0 < NTYPES < 11
DPO 9 List types on next line if 0 < NTYPES < 9
NMAX INTEGER
The maximum allowable value for N
MAXIN INTEGER
The number of different values that can be used for each of
M, N, NRHS, NB, and NX
MAXRHS INTEGER
The maximum number of right hand sides
NIN INTEGER
The unit number for input
NOUT INTEGER
The unit number for output
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
subroutine zchkeq (double precision THRESH, integer NOUT)
ZCHKEQ
Purpose:
ZCHKEQ tests ZGEEQU, ZGBEQU, ZPOEQU, ZPPEQU and ZPBEQU
Parameters:
THRESH
THRESH is DOUBLE PRECISION
Threshold for testing routines. Should be between 2 and 10.
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchkgb (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
complex*16, dimension( * ) A, integer LA, complex*16, dimension( * ) AFAC, integer LAFAC,
complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
dimension( * ) IWORK, integer NOUT)
ZCHKGB
Purpose:
ZCHKGB tests ZGBTRF, -TRS, -RFS, and -CON
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is COMPLEX*16 array, dimension (LA)
LA
LA is INTEGER
The length of the array A. LA >= (KLMAX+KUMAX+1)*NMAX
where KLMAX is the largest entry in the local array KLVAL,
KUMAX is the largest entry in the local array KUVAL and
NMAX is the largest entry in the input array NVAL.
AFAC
AFAC is COMPLEX*16 array, dimension (LAFAC)
LAFAC
LAFAC is INTEGER
The length of the array AFAC. LAFAC >= (2*KLMAX+KUMAX+1)*NMAX
where KLMAX is the largest entry in the local array KLVAL,
KUMAX is the largest entry in the local array KUVAL and
NMAX is the largest entry in the input array NVAL.
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NSMAX,NMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(max(NMAX,2*NSMAX))
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchkge (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16,
dimension( * ) AINV, complex*16, dimension( * ) B, complex*16, dimension( * ) X,
complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
ZCHKGE
Purpose:
ZCHKGE tests ZGETRF, -TRI, -TRS, -RFS, and -CON.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(max(2*NMAX,2*NSMAX+NWORK))
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchkgt (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
complex*16, dimension( * ) A, complex*16, dimension( * ) AF, complex*16, dimension( * ) B,
complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension( * )
WORK, double precision, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
ZCHKGT
Purpose:
ZCHKGT tests ZGTTRF, -TRS, -RFS, and -CON
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is COMPLEX*16 array, dimension (NMAX*4)
AF
AF is COMPLEX*16 array, dimension (NMAX*4)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(max(NMAX)+2*NSMAX)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchkhe (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * ) NSVAL,
double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * ) A,
complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16, dimension( *
) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension(
* ) WORK, double precision, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer
NOUT)
ZCHKHE
Purpose:
ZCHKHE tests ZHETRF, -TRI2, -TRS, -TRS2, -RFS, and -CON.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX))
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zchkhe_rook (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * )
NVAL, integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * )
NSVAL, double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * )
A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16,
dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT,
complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
dimension( * ) IWORK, integer NOUT)
ZCHKHE_ROOK
Purpose:
ZCHKHE_ROOK tests ZHETRF_ROOK, -TRI_ROOK, -TRS_ROOK,
and -CON_ROOK.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is CCOMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is CCOMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX)
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zchkhp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16,
dimension( * ) AINV, complex*16, dimension( * ) B, complex*16, dimension( * ) X,
complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
ZCHKHP
Purpose:
ZCHKHP tests ZHPTRF, -TRI, -TRS, -RFS, and -CON
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
AFAC
AFAC is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
AINV
AINV is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(2,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array,
dimension (NMAX+2*NSMAX)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchklq (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
integer, dimension( * ) NXVAL, integer NRHS, double precision THRESH, logical TSTERR,
integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AF, complex*16,
dimension( * ) AQ, complex*16, dimension( * ) AL, complex*16, dimension( * ) AC,
complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
XACT, complex*16, dimension( * ) TAU, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer NOUT)
ZCHKLQ
Purpose:
ZCHKLQ tests ZGELQF, ZUNGLQ and CUNMLQ.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB and NX contained in the
vectors NBVAL and NXVAL. The blocking parameters are used
in pairs (NB,NX).
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NXVAL
NXVAL is INTEGER array, dimension (NNB)
The values of the crossover point NX.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AF
AF is COMPLEX*16 array, dimension (NMAX*NMAX)
AQ
AQ is COMPLEX*16 array, dimension (NMAX*NMAX)
AL
AL is COMPLEX*16 array, dimension (NMAX*NMAX)
AC
AC is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
TAU
TAU is COMPLEX*16 array, dimension (NMAX)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*NMAX)
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchkpb (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * ) NSVAL,
double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * ) A,
complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16, dimension( *
) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension(
* ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
ZCHKPB
Purpose:
ZCHKPB tests ZPBTRF, -TRS, -RFS, and -CON.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is DOUBLE PRECISION array, dimension (NMAX*NMAX)
AFAC
AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX)
AINV
AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX)
B
B is DOUBLE PRECISION array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is DOUBLE PRECISION array, dimension (NMAX*NSMAX)
XACT
XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX)
WORK
WORK is DOUBLE PRECISION array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(max(NMAX,2*NSMAX))
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchkpo (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * ) NSVAL,
double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * ) A,
complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16, dimension( *
) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension(
* ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
ZCHKPO
Purpose:
ZCHKPO tests ZPOTRF, -TRI, -TRS, -RFS, and -CON
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(NMAX+2*NSMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchkpp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16,
dimension( * ) AINV, complex*16, dimension( * ) B, complex*16, dimension( * ) X,
complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer NOUT)
ZCHKPP
Purpose:
ZCHKPP tests ZPPTRF, -TRI, -TRS, -RFS, and -CON
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
AFAC
AFAC is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
AINV
AINV is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(max(NMAX,2*NSMAX))
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchkps (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NNB, integer, dimension( * ) NBVAL, integer NRANK, integer, dimension( * )
RANKVAL, double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * )
A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) PERM, integer, dimension( *
) PIV, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer
NOUT)
ZCHKPS
Purpose:
ZCHKPS tests ZPSTRF.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the block size NB.
NRANK
NRANK is INTEGER
The number of values of RANK contained in the vector RANKVAL.
RANKVAL
RANKVAL is INTEGER array, dimension (NBVAL)
The values of the block size NB.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
PERM
PERM is COMPLEX*16 array, dimension (NMAX*NMAX)
PIV
PIV is INTEGER array, dimension (NMAX)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*3)
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchkpt (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
complex*16, dimension( * ) A, double precision, dimension( * ) D, complex*16, dimension( *
) E, complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( *
) XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer
NOUT)
ZCHKPT
Purpose:
ZCHKPT tests ZPTTRF, -TRS, -RFS, and -CON
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is COMPLEX*16 array, dimension (NMAX*2)
D
D is DOUBLE PRECISION array, dimension (NMAX*2)
E
E is COMPLEX*16 array, dimension (NMAX*2)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(max(NMAX,2*NSMAX))
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchkq3 (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
integer, dimension( * ) NXVAL, double precision THRESH, complex*16, dimension( * ) A,
complex*16, dimension( * ) COPYA, double precision, dimension( * ) S, complex*16,
dimension( * ) TAU, complex*16, dimension( * ) WORK, double precision, dimension( * )
RWORK, integer, dimension( * ) IWORK, integer NOUT)
ZCHKQ3
Purpose:
ZCHKQ3 tests ZGEQP3.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB and NX contained in the
vectors NBVAL and NXVAL. The blocking parameters are used
in pairs (NB,NX).
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NXVAL
NXVAL is INTEGER array, dimension (NNB)
The values of the crossover point NX.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
A
A is COMPLEX*16 array, dimension (MMAX*NMAX)
where MMAX is the maximum value of M in MVAL and NMAX is the
maximum value of N in NVAL.
COPYA
COPYA is COMPLEX*16 array, dimension (MMAX*NMAX)
S
S is DOUBLE PRECISION array, dimension
(min(MMAX,NMAX))
TAU
TAU is COMPLEX*16 array, dimension (MMAX)
WORK
WORK is COMPLEX*16 array, dimension
(max(M*max(M,N) + 4*min(M,N) + max(M,N)))
RWORK
RWORK is DOUBLE PRECISION array, dimension (4*NMAX)
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchkql (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
integer, dimension( * ) NXVAL, integer NRHS, double precision THRESH, logical TSTERR,
integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AF, complex*16,
dimension( * ) AQ, complex*16, dimension( * ) AL, complex*16, dimension( * ) AC,
complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
XACT, complex*16, dimension( * ) TAU, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer NOUT)
ZCHKQL
Purpose:
ZCHKQL tests ZGEQLF, ZUNGQL and CUNMQL.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB and NX contained in the
vectors NBVAL and NXVAL. The blocking parameters are used
in pairs (NB,NX).
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NXVAL
NXVAL is INTEGER array, dimension (NNB)
The values of the crossover point NX.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AF
AF is COMPLEX*16 array, dimension (NMAX*NMAX)
AQ
AQ is COMPLEX*16 array, dimension (NMAX*NMAX)
AL
AL is COMPLEX*16 array, dimension (NMAX*NMAX)
AC
AC is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
TAU
TAU is COMPLEX*16 array, dimension (NMAX)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*NMAX)
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchkqr (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
integer, dimension( * ) NXVAL, integer NRHS, double precision THRESH, logical TSTERR,
integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AF, complex*16,
dimension( * ) AQ, complex*16, dimension( * ) AR, complex*16, dimension( * ) AC,
complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
XACT, complex*16, dimension( * ) TAU, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
ZCHKQR
Purpose:
ZCHKQR tests ZGEQRF, ZUNGQR and CUNMQR.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB and NX contained in the
vectors NBVAL and NXVAL. The blocking parameters are used
in pairs (NB,NX).
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NXVAL
NXVAL is INTEGER array, dimension (NNB)
The values of the crossover point NX.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AF
AF is COMPLEX*16 array, dimension (NMAX*NMAX)
AQ
AQ is COMPLEX*16 array, dimension (NMAX*NMAX)
AR
AR is COMPLEX*16 array, dimension (NMAX*NMAX)
AC
AC is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
TAU
TAU is COMPLEX*16 array, dimension (NMAX)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*NMAX)
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zchkqrt (double precision THRESH, logical TSTERR, integer NM, integer, dimension( *
) MVAL, integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * )
NBVAL, integer NOUT)
ZCHKQRT
Purpose:
ZCHKQRT tests ZGEQRT and ZGEMQRT.
Parameters:
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchkqrtp (double precision THRESH, logical TSTERR, integer NM, integer, dimension(
* ) MVAL, integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * )
NBVAL, integer NOUT)
ZCHKQRTP
Purpose:
ZCHKQRTP tests ZTPQRT and ZTPMQRT.
Parameters:
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
program zchkrfp ()
ZCHKRFP
Purpose:
ZCHKRFP is the main test program for the COMPLEX*16 linear equation
routines with RFP storage format
MAXIN INTEGER
The number of different values that can be used for each of
M, N, or NB
MAXRHS INTEGER
The maximum number of right hand sides
NTYPES INTEGER
NMAX INTEGER
The maximum allowable value for N.
NIN INTEGER
The unit number for input
NOUT INTEGER
The unit number for output
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
subroutine zchkrq (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
integer NN, integer, dimension( * ) NVAL, integer NNB, integer, dimension( * ) NBVAL,
integer, dimension( * ) NXVAL, integer NRHS, double precision THRESH, logical TSTERR,
integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AF, complex*16,
dimension( * ) AQ, complex*16, dimension( * ) AR, complex*16, dimension( * ) AC,
complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
XACT, complex*16, dimension( * ) TAU, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
ZCHKRQ
Purpose:
ZCHKRQ tests ZGERQF, ZUNGRQ and CUNMRQ.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB and NX contained in the
vectors NBVAL and NXVAL. The blocking parameters are used
in pairs (NB,NX).
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NXVAL
NXVAL is INTEGER array, dimension (NNB)
The values of the crossover point NX.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AF
AF is COMPLEX*16 array, dimension (NMAX*NMAX)
AQ
AQ is COMPLEX*16 array, dimension (NMAX*NMAX)
AR
AR is COMPLEX*16 array, dimension (NMAX*NMAX)
AC
AC is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
TAU
TAU is COMPLEX*16 array, dimension (NMAX)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*NMAX)
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchksp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16,
dimension( * ) AINV, complex*16, dimension( * ) B, complex*16, dimension( * ) X,
complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
ZCHKSP
Purpose:
ZCHKSP tests ZSPTRF, -TRI, -TRS, -RFS, and -CON
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
AFAC
AFAC is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
AINV
AINV is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(2,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array,
dimension (NMAX+2*NSMAX)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchksy (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * ) NSVAL,
double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * ) A,
complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16, dimension( *
) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension(
* ) WORK, double precision, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer
NOUT)
ZCHKSY
Purpose:
ZCHKSY tests ZSYTRF, -TRI2, -TRS, -TRS2, -RFS, and -CON.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*max(2,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NSMAX)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zchksy_rook (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * )
NVAL, integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * )
NSVAL, double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * )
A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16,
dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT,
complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
dimension( * ) IWORK, integer NOUT)
ZCHKSY_ROOK
Purpose:
ZCHKSY_ROOK tests ZSYTRF_ROOK, -TRI_ROOK, -TRS_ROOK,
and -CON_ROOK.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NBVAL)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX))
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zchktb (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
integer NMAX, complex*16, dimension( * ) AB, complex*16, dimension( * ) AINV, complex*16,
dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT,
complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
ZCHKTB
Purpose:
ZCHKTB tests ZTBTRS, -RFS, and -CON, and ZLATBS.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The leading dimension of the work arrays.
NMAX >= the maximum value of N in NVAL.
AB
AB is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(max(NMAX,2*NSMAX))
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchktp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, logical TSTERR,
integer NMAX, complex*16, dimension( * ) AP, complex*16, dimension( * ) AINVP, complex*16,
dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT,
complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
ZCHKTP
Purpose:
ZCHKTP tests ZTPTRI, -TRS, -RFS, and -CON, and ZLATPS
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The leading dimension of the work arrays. NMAX >= the
maximumm value of N in NVAL.
AP
AP is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
AINVP
AINVP is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(max(NMAX,2*NSMAX))
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchktr (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NNB, integer, dimension( * ) NBVAL, integer NNS, integer, dimension( * ) NSVAL,
double precision THRESH, logical TSTERR, integer NMAX, complex*16, dimension( * ) A,
complex*16, dimension( * ) AINV, complex*16, dimension( * ) B, complex*16, dimension( * )
X, complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer NOUT)
ZCHKTR
Purpose:
ZCHKTR tests ZTRTRI, -TRS, -RFS, and -CON, and ZLATRS
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB contained in the vector NBVAL.
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The leading dimension of the work arrays.
NMAX >= the maximum value of N in NVAL.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(max(NMAX,2*NSMAX))
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zchktz (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
integer NN, integer, dimension( * ) NVAL, double precision THRESH, logical TSTERR,
complex*16, dimension( * ) A, complex*16, dimension( * ) COPYA, double precision,
dimension( * ) S, complex*16, dimension( * ) TAU, complex*16, dimension( * ) WORK, double
precision, dimension( * ) RWORK, integer NOUT)
ZCHKTZ
Purpose:
ZCHKTZ tests ZTZRZF.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is COMPLEX*16 array, dimension (MMAX*NMAX)
where MMAX is the maximum value of M in MVAL and NMAX is the
maximum value of N in NVAL.
COPYA
COPYA is COMPLEX*16 array, dimension (MMAX*NMAX)
S
S is DOUBLE PRECISION array, dimension
(min(MMAX,NMAX))
TAU
TAU is COMPLEX*16 array, dimension (MMAX)
WORK
WORK is COMPLEX*16 array, dimension
(MMAX*NMAX + 4*NMAX + MMAX)
RWORK
RWORK is DOUBLE PRECISION array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zdrvab (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, integer NMAX,
complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * )
B, complex*16, dimension( * ) X, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, complex, dimension( * ) SWORK, integer, dimension( * ) IWORK,
integer NOUT)
ZDRVAB
Purpose:
ZDRVAB tests ZCGESV
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
NMAX
NMAX is INTEGER
The maximum value permitted for M or N, used in dimensioning
the work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
where NSMAX is the largest entry in NSVAL.
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NSMAX*2))
RWORK
RWORK is DOUBLE PRECISION array, dimension
NMAX
SWORK
SWORK is COMPLEX array, dimension
(NMAX*(NSMAX+NMAX))
IWORK
IWORK is INTEGER array, dimension
NMAX
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zdrvac (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
integer NNS, integer, dimension( * ) NSVAL, double precision THRESH, integer NMAX,
complex*16, dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * )
B, complex*16, dimension( * ) X, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, complex, dimension(*) SWORK, integer NOUT)
ZDRVAC
Purpose:
ZDRVAC tests ZCPOSV.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NM
NM is INTEGER
The number of values of N contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NSMAX)
X
X is COMPLEX*16 array, dimension (NMAX*NSMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NSMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(max(2*NMAX,2*NSMAX+NWORK))
SWORK
SWORK is COMPLEX array, dimension
(NMAX*(NSMAX+NMAX))
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zdrvgb (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NRHS, double precision THRESH, logical TSTERR, complex*16, dimension( * ) A,
integer LA, complex*16, dimension( * ) AFB, integer LAFB, complex*16, dimension( * ) ASAV,
complex*16, dimension( * ) B, complex*16, dimension( * ) BSAV, complex*16, dimension( * )
X, complex*16, dimension( * ) XACT, double precision, dimension( * ) S, complex*16,
dimension( * ) WORK, double precision, dimension( * ) RWORK, integer, dimension( * )
IWORK, integer NOUT)
ZDRVGB ZDRVGBX
Purpose:
ZDRVGB tests the driver routines ZGBSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is COMPLEX*16 array, dimension (LA)
LA
LA is INTEGER
The length of the array A. LA >= (2*NMAX-1)*NMAX
where NMAX is the largest entry in NVAL.
AFB
AFB is COMPLEX*16 array, dimension (LAFB)
LAFB
LAFB is INTEGER
The length of the array AFB. LAFB >= (3*NMAX-2)*NMAX
where NMAX is the largest entry in NVAL.
ASAV
ASAV is COMPLEX*16 array, dimension (LA)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
BSAV
BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
S
S is DOUBLE PRECISION array, dimension (2*NMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NRHS,NMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(max(NMAX,2*NRHS))
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
Purpose:
ZDRVGB tests the driver routines ZGBSV, -SVX, and -SVXX.
Note that this file is used only when the XBLAS are available,
otherwise zdrvgb.f defines this subroutine.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is COMPLEX*16 array, dimension (LA)
LA
LA is INTEGER
The length of the array A. LA >= (2*NMAX-1)*NMAX
where NMAX is the largest entry in NVAL.
AFB
AFB is COMPLEX*16 array, dimension (LAFB)
LAFB
LAFB is INTEGER
The length of the array AFB. LAFB >= (3*NMAX-2)*NMAX
where NMAX is the largest entry in NVAL.
ASAV
ASAV is COMPLEX*16 array, dimension (LA)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
BSAV
BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
S
S is DOUBLE PRECISION array, dimension (2*NMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NRHS,NMAX))
RWORK
RWORK is DOUBLE PRECISION array, dimension
(max(NMAX,2*NRHS))
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zdrvge (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) ASAV,
complex*16, dimension( * ) B, complex*16, dimension( * ) BSAV, complex*16, dimension( * )
X, complex*16, dimension( * ) XACT, double precision, dimension( * ) S, complex*16,
dimension( * ) WORK, double precision, dimension( * ) RWORK, integer, dimension( * )
IWORK, integer NOUT)
ZDRVGE ZDRVGEX
Purpose:
ZDRVGE tests the driver routines ZGESV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
ASAV
ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
BSAV
BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
S
S is DOUBLE PRECISION array, dimension (2*NMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (2*NRHS+NMAX)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
Purpose:
ZDRVGE tests the driver routines ZGESV, -SVX, and -SVXX.
Note that this file is used only when the XBLAS are available,
otherwise zdrvge.f defines this subroutine.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
ASAV
ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
BSAV
BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
S
S is DOUBLE PRECISION array, dimension (2*NMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (2*NRHS+NMAX)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
subroutine zdrvgt (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NRHS, double precision THRESH, logical TSTERR, complex*16, dimension( * ) A,
complex*16, dimension( * ) AF, complex*16, dimension( * ) B, complex*16, dimension( * ) X,
complex*16, dimension( * ) XACT, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer, dimension( * ) IWORK, integer NOUT)
ZDRVGT
Purpose:
ZDRVGT tests ZGTSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand sides, NRHS >= 0.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is COMPLEX*16 array, dimension (NMAX*4)
AF
AF is COMPLEX*16 array, dimension (NMAX*4)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (2*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zdrvhe (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV,
complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
dimension( * ) IWORK, integer NOUT)
ZDRVHE ZDRVHEX
Purpose:
ZDRVHE tests the driver routines ZHESV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
Purpose:
ZDRVHE tests the driver routines ZHESV, -SVX, and -SVXX.
Note that this file is used only when the XBLAS are available,
otherwise zdrvhe.f defines this subroutine.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(2,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (2*NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
subroutine zdrvhe_rook (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * )
NVAL, integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV,
complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
dimension( * ) IWORK, integer NOUT)
ZDRVHE_ROOK
Purpose:
ZDRVHE_ROOK tests the driver routines ZHESV_ROOK.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zdrvhp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV,
complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
dimension( * ) IWORK, integer NOUT)
ZDRVHP
Purpose:
ZDRVHP tests the driver routines ZHPSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
AFAC
AFAC is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
AINV
AINV is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(2,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zdrvls (logical, dimension( * ) DOTYPE, integer NM, integer, dimension( * ) MVAL,
integer NN, integer, dimension( * ) NVAL, integer NNS, integer, dimension( * ) NSVAL,
integer NNB, integer, dimension( * ) NBVAL, integer, dimension( * ) NXVAL, double
precision THRESH, logical TSTERR, complex*16, dimension( * ) A, complex*16, dimension( * )
COPYA, complex*16, dimension( * ) B, complex*16, dimension( * ) COPYB, complex*16,
dimension( * ) C, double precision, dimension( * ) S, double precision, dimension( * )
COPYS, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
dimension( * ) IWORK, integer NOUT)
ZDRVLS
Purpose:
ZDRVLS tests the least squares driver routines ZGELS, CGELSS, ZGELSY
and CGELSD.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
The matrix of type j is generated as follows:
j=1: A = U*D*V where U and V are random unitary matrices
and D has random entries (> 0.1) taken from a uniform
distribution (0,1). A is full rank.
j=2: The same of 1, but A is scaled up.
j=3: The same of 1, but A is scaled down.
j=4: A = U*D*V where U and V are random unitary matrices
and D has 3*min(M,N)/4 random entries (> 0.1) taken
from a uniform distribution (0,1) and the remaining
entries set to 0. A is rank-deficient.
j=5: The same of 4, but A is scaled up.
j=6: The same of 5, but A is scaled down.
NM
NM is INTEGER
The number of values of M contained in the vector MVAL.
MVAL
MVAL is INTEGER array, dimension (NM)
The values of the matrix row dimension M.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix column dimension N.
NNB
NNB is INTEGER
The number of values of NB and NX contained in the
vectors NBVAL and NXVAL. The blocking parameters are used
in pairs (NB,NX).
NBVAL
NBVAL is INTEGER array, dimension (NNB)
The values of the blocksize NB.
NXVAL
NXVAL is INTEGER array, dimension (NNB)
The values of the crossover point NX.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right hand sides NRHS.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is COMPLEX*16 array, dimension (MMAX*NMAX)
where MMAX is the maximum value of M in MVAL and NMAX is the
maximum value of N in NVAL.
COPYA
COPYA is COMPLEX*16 array, dimension (MMAX*NMAX)
B
B is COMPLEX*16 array, dimension (MMAX*NSMAX)
where MMAX is the maximum value of M in MVAL and NSMAX is the
maximum value of NRHS in NSVAL.
COPYB
COPYB is COMPLEX*16 array, dimension (MMAX*NSMAX)
C
C is COMPLEX*16 array, dimension (MMAX*NSMAX)
S
S is DOUBLE PRECISION array, dimension
(min(MMAX,NMAX))
COPYS
COPYS is DOUBLE PRECISION array, dimension
(min(MMAX,NMAX))
WORK
WORK is COMPLEX*16 array, dimension
(MMAX*NMAX + 4*NMAX + MMAX).
RWORK
RWORK is DOUBLE PRECISION array, dimension (5*NMAX-1)
IWORK
IWORK is INTEGER array, dimension (15*NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zdrvpb (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) ASAV,
complex*16, dimension( * ) B, complex*16, dimension( * ) BSAV, complex*16, dimension( * )
X, complex*16, dimension( * ) XACT, double precision, dimension( * ) S, complex*16,
dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
ZDRVPB
Purpose:
ZDRVPB tests the driver routines ZPBSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
ASAV
ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
BSAV
BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
S
S is DOUBLE PRECISION array, dimension (NMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zdrvpo (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) ASAV,
complex*16, dimension( * ) B, complex*16, dimension( * ) BSAV, complex*16, dimension( * )
X, complex*16, dimension( * ) XACT, double precision, dimension( * ) S, complex*16,
dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
ZDRVPO ZDRVPOX
Purpose:
ZDRVPO tests the driver routines ZPOSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
ASAV
ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
BSAV
BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
S
S is DOUBLE PRECISION array, dimension (NMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
Purpose:
ZDRVPO tests the driver routines ZPOSV, -SVX, and -SVXX.
Note that this file is used only when the XBLAS are available,
otherwise zdrvpo.f defines this subroutine.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
ASAV
ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
BSAV
BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
S
S is DOUBLE PRECISION array, dimension (NMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zdrvpp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) ASAV,
complex*16, dimension( * ) B, complex*16, dimension( * ) BSAV, complex*16, dimension( * )
X, complex*16, dimension( * ) XACT, double precision, dimension( * ) S, complex*16,
dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
ZDRVPP
Purpose:
ZDRVPP tests the driver routines ZPPSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
ASAV
ASAV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
BSAV
BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
S
S is DOUBLE PRECISION array, dimension (NMAX)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zdrvpt (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NRHS, double precision THRESH, logical TSTERR, complex*16, dimension( * ) A,
double precision, dimension( * ) D, complex*16, dimension( * ) E, complex*16, dimension( *
) B, complex*16, dimension( * ) X, complex*16, dimension( * ) XACT, complex*16, dimension(
* ) WORK, double precision, dimension( * ) RWORK, integer NOUT)
ZDRVPT
Purpose:
ZDRVPT tests ZPTSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
A
A is COMPLEX*16 array, dimension (NMAX*2)
D
D is DOUBLE PRECISION array, dimension (NMAX*2)
E
E is COMPLEX*16 array, dimension (NMAX*2)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(3,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zdrvrf1 (integer NOUT, integer NN, integer, dimension( nn ) NVAL, double precision
THRESH, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) ARF,
double precision, dimension( * ) WORK)
ZDRVRF1
Purpose:
ZDRVRF1 tests the LAPACK RFP routines:
ZLANHF.F
Parameters:
NOUT
NOUT is INTEGER
The unit number for output.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
A
A is COMPLEX*16 array, dimension (LDA,NMAX)
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,NMAX).
ARF
ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).
WORK
WORK is DOUBLE PRECISION array, dimension ( NMAX )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zdrvrf2 (integer NOUT, integer NN, integer, dimension( nn ) NVAL, complex*16,
dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) ARF, complex*16,
dimension(*) AP, complex*16, dimension( lda, * ) ASAV)
ZDRVRF2
Purpose:
ZDRVRF2 tests the LAPACK RFP convertion routines.
Parameters:
NOUT
NOUT is INTEGER
The unit number for output.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
A
A is COMPLEX*16 array, dimension (LDA,NMAX)
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,NMAX).
ARF
ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).
AP
AP is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).
ASAV
ASAV is COMPLEX*16 array, dimension (LDA,NMAX)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zdrvrf3 (integer NOUT, integer NN, integer, dimension( nn ) NVAL, double precision
THRESH, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) ARF,
complex*16, dimension( lda, * ) B1, complex*16, dimension( lda, * ) B2, double precision,
dimension( * ) D_WORK_ZLANGE, complex*16, dimension( * ) Z_WORK_ZGEQRF, complex*16,
dimension( * ) TAU)
ZDRVRF3
Purpose:
ZDRVRF3 tests the LAPACK RFP routines:
ZTFSM
Parameters:
NOUT
NOUT is INTEGER
The unit number for output.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
A
A is COMPLEX*16 array, dimension (LDA,NMAX)
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,NMAX).
ARF
ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).
B1
B1 is COMPLEX*16 array, dimension (LDA,NMAX)
B2
B2 is COMPLEX*16 array, dimension (LDA,NMAX)
D_WORK_ZLANGE
D_WORK_ZLANGE is DOUBLE PRECISION array, dimension (NMAX)
Z_WORK_ZGEQRF
Z_WORK_ZGEQRF is COMPLEX*16 array, dimension (NMAX)
TAU
TAU is COMPLEX*16 array, dimension (NMAX)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zdrvrf4 (integer NOUT, integer NN, integer, dimension( nn ) NVAL, double precision
THRESH, complex*16, dimension( ldc, * ) C1, complex*16, dimension( ldc, *) C2, integer
LDC, complex*16, dimension( * ) CRF, complex*16, dimension( lda, * ) A, integer LDA,
double precision, dimension( * ) D_WORK_ZLANGE)
ZDRVRF4
Purpose:
ZDRVRF4 tests the LAPACK RFP routines:
ZHFRK
Parameters:
NOUT
NOUT is INTEGER
The unit number for output.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
C1
C1 is COMPLEX*16 array, dimension (LDC,NMAX)
C2
C2 is COMPLEX*16 array, dimension (LDC,NMAX)
LDC
LDC is INTEGER
The leading dimension of the array A. LDA >= max(1,NMAX).
CRF
CRF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).
A
A is COMPLEX*16 array, dimension (LDA,NMAX)
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,NMAX).
D_WORK_ZLANGE
D_WORK_ZLANGE is DOUBLE PRECISION array, dimension (NMAX)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zdrvrfp (integer NOUT, integer NN, integer, dimension( nn ) NVAL, integer NNS,
integer, dimension( nns ) NSVAL, integer NNT, integer, dimension( nnt ) NTVAL, double
precision THRESH, complex*16, dimension( * ) A, complex*16, dimension( * ) ASAV,
complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV, complex*16, dimension( *
) B, complex*16, dimension( * ) BSAV, complex*16, dimension( * ) XACT, complex*16,
dimension( * ) X, complex*16, dimension( * ) ARF, complex*16, dimension( * ) ARFINV,
complex*16, dimension( * ) Z_WORK_ZLATMS, complex*16, dimension( * ) Z_WORK_ZPOT02,
complex*16, dimension( * ) Z_WORK_ZPOT03, double precision, dimension( * ) D_WORK_ZLATMS,
double precision, dimension( * ) D_WORK_ZLANHE, double precision, dimension( * )
D_WORK_ZPOT01, double precision, dimension( * ) D_WORK_ZPOT02, double precision,
dimension( * ) D_WORK_ZPOT03)
ZDRVRFP
Purpose:
ZDRVRFP tests the LAPACK RFP routines:
ZPFTRF, ZPFTRS, and ZPFTRI.
This testing routine follow the same tests as ZDRVPO (test for the full
format Symmetric Positive Definite solver).
The tests are performed in Full Format, convertion back and forth from
full format to RFP format are performed using the routines ZTRTTF and
ZTFTTR.
First, a specific matrix A of size N is created. There is nine types of
different matrixes possible.
1. Diagonal 6. Random, CNDNUM = sqrt(0.1/EPS)
2. Random, CNDNUM = 2 7. Random, CNDNUM = 0.1/EPS
*3. First row and column zero 8. Scaled near underflow
*4. Last row and column zero 9. Scaled near overflow
*5. Middle row and column zero
(* - tests error exits from ZPFTRF, no test ratios are computed)
A solution XACT of size N-by-NRHS is created and the associated right
hand side B as well. Then ZPFTRF is called to compute L (or U), the
Cholesky factor of A. Then L (or U) is used to solve the linear system
of equations AX = B. This gives X. Then L (or U) is used to compute the
inverse of A, AINV. The following four tests are then performed:
(1) norm( L*L' - A ) / ( N * norm(A) * EPS ) or
norm( U'*U - A ) / ( N * norm(A) * EPS ),
(2) norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
(3) norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ),
(4) ( norm(X-XACT) * RCOND ) / ( norm(XACT) * EPS ),
where EPS is the machine precision, RCOND the condition number of A, and
norm( . ) the 1-norm for (1,2,3) and the inf-norm for (4).
Errors occur when INFO parameter is not as expected. Failures occur when
a test ratios is greater than THRES.
Parameters:
NOUT
NOUT is INTEGER
The unit number for output.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NNS
NNS is INTEGER
The number of values of NRHS contained in the vector NSVAL.
NSVAL
NSVAL is INTEGER array, dimension (NNS)
The values of the number of right-hand sides NRHS.
NNT
NNT is INTEGER
The number of values of MATRIX TYPE contained in the vector NTVAL.
NTVAL
NTVAL is INTEGER array, dimension (NNT)
The values of matrix type (between 0 and 9 for PO/PP/PF matrices).
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
ASAV
ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*MAXRHS)
BSAV
BSAV is COMPLEX*16 array, dimension (NMAX*MAXRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*MAXRHS)
X
X is COMPLEX*16 array, dimension (NMAX*MAXRHS)
ARF
ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2)
ARFINV
ARFINV is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2)
Z_WORK_ZLATMS
Z_WORK_ZLATMS is COMPLEX*16 array, dimension ( 3*NMAX )
Z_WORK_ZPOT02
Z_WORK_ZPOT02 is COMPLEX*16 array, dimension ( NMAX*MAXRHS )
Z_WORK_ZPOT03
Z_WORK_ZPOT03 is COMPLEX*16 array, dimension ( NMAX*NMAX )
D_WORK_ZLATMS
D_WORK_ZLATMS is DOUBLE PRECISION array, dimension ( NMAX )
D_WORK_ZLANHE
D_WORK_ZLANHE is DOUBLE PRECISION array, dimension ( NMAX )
D_WORK_ZPOT01
D_WORK_ZPOT01 is DOUBLE PRECISION array, dimension ( NMAX )
D_WORK_ZPOT02
D_WORK_ZPOT02 is DOUBLE PRECISION array, dimension ( NMAX )
D_WORK_ZPOT03
D_WORK_ZPOT03 is DOUBLE PRECISION array, dimension ( NMAX )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zdrvsp (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV,
complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
dimension( * ) IWORK, integer NOUT)
ZDRVSP
Purpose:
ZDRVSP tests the driver routines ZSPSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
AFAC
AFAC is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
AINV
AINV is COMPLEX*16 array, dimension
(NMAX*(NMAX+1)/2)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(2,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zdrvsy (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * ) NVAL,
integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV,
complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
dimension( * ) IWORK, integer NOUT)
ZDRVSY ZDRVSYX
Purpose:
ZDRVSY tests the driver routines ZSYSV and -SVX.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
Purpose:
ZDRVSY tests the driver routines ZSYSV, -SVX, and -SVXX.
Note that this file is used only when the XBLAS are available,
otherwise zdrvsy.f defines this subroutine.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
WORK
WORK is COMPLEX*16 array, dimension
(NMAX*max(2,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (2*NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
subroutine zdrvsy_rook (logical, dimension( * ) DOTYPE, integer NN, integer, dimension( * )
NVAL, integer NRHS, double precision THRESH, logical TSTERR, integer NMAX, complex*16,
dimension( * ) A, complex*16, dimension( * ) AFAC, complex*16, dimension( * ) AINV,
complex*16, dimension( * ) B, complex*16, dimension( * ) X, complex*16, dimension( * )
XACT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer,
dimension( * ) IWORK, integer NOUT)
ZDRVSY_ROOK
Purpose:
ZDRVSY_ROOK tests the driver routines ZSYSV_ROOK.
Parameters:
DOTYPE
DOTYPE is LOGICAL array, dimension (NTYPES)
The matrix types to be used for testing. Matrices of type j
(for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) =
.TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
NN
NN is INTEGER
The number of values of N contained in the vector NVAL.
NVAL
NVAL is INTEGER array, dimension (NN)
The values of the matrix dimension N.
NRHS
NRHS is INTEGER
The number of right hand side vectors to be generated for
each linear system.
THRESH
THRESH is DOUBLE PRECISION
The threshold value for the test ratios. A result is
included in the output file if RESULT >= THRESH. To have
every test ratio printed, use THRESH = 0.
TSTERR
TSTERR is LOGICAL
Flag that indicates whether error exits are to be tested.
NMAX
NMAX is INTEGER
The maximum value permitted for N, used in dimensioning the
work arrays.
A
A is COMPLEX*16 array, dimension (NMAX*NMAX)
AFAC
AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
AINV
AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
B
B is COMPLEX*16 array, dimension (NMAX*NRHS)
X
X is COMPLEX*16 array, dimension (NMAX*NRHS)
XACT
XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
WORK
WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))
RWORK
RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
IWORK
IWORK is INTEGER array, dimension (NMAX)
NOUT
NOUT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zebchvxx (double precision THRESH, character*3 PATH)
ZEBCHVXX Purpose:
ZEBCHVXX will run Z**SVXX on a series of Hilbert matrices and then
compare the error bounds returned by Z**SVXX to see if the returned
answer indeed falls within those bounds.
Eight test ratios will be computed. The tests will pass if they are .LT.
THRESH. There are two cases that are determined by 1 / (SQRT( N ) * EPS).
If that value is .LE. to the component wise reciprocal condition number,
it uses the guaranteed case, other wise it uses the unguaranteed case.
Test ratios:
Let Xc be X_computed and Xt be X_truth.
The norm used is the infinity norm.
Let A be the guaranteed case and B be the unguaranteed case.
1. Normwise guaranteed forward error bound.
A: norm ( abs( Xc - Xt ) / norm ( Xt ) .LE. ERRBND( *, nwise_i, bnd_i ) and
ERRBND( *, nwise_i, bnd_i ) .LE. MAX(SQRT(N),10) * EPS.
If these conditions are met, the test ratio is set to be
ERRBND( *, nwise_i, bnd_i ) / MAX(SQRT(N), 10). Otherwise it is 1/EPS.
B: For this case, CGESVXX should just return 1. If it is less than
one, treat it the same as in 1A. Otherwise it fails. (Set test
ratio to ERRBND( *, nwise_i, bnd_i ) * THRESH?)
2. Componentwise guaranteed forward error bound.
A: norm ( abs( Xc(j) - Xt(j) ) ) / norm (Xt(j)) .LE. ERRBND( *, cwise_i, bnd_i )
for all j .AND. ERRBND( *, cwise_i, bnd_i ) .LE. MAX(SQRT(N), 10) * EPS.
If these conditions are met, the test ratio is set to be
ERRBND( *, cwise_i, bnd_i ) / MAX(SQRT(N), 10). Otherwise it is 1/EPS.
B: Same as normwise test ratio.
3. Backwards error.
A: The test ratio is set to BERR/EPS.
B: Same test ratio.
4. Reciprocal condition number.
A: A condition number is computed with Xt and compared with the one
returned from CGESVXX. Let RCONDc be the RCOND returned by CGESVXX
and RCONDt be the RCOND from the truth value. Test ratio is set to
MAX(RCONDc/RCONDt, RCONDt/RCONDc).
B: Test ratio is set to 1 / (EPS * RCONDc).
5. Reciprocal normwise condition number.
A: The test ratio is set to
MAX(ERRBND( *, nwise_i, cond_i ) / NCOND, NCOND / ERRBND( *, nwise_i, cond_i )).
B: Test ratio is set to 1 / (EPS * ERRBND( *, nwise_i, cond_i )).
6. Reciprocal componentwise condition number.
A: Test ratio is set to
MAX(ERRBND( *, cwise_i, cond_i ) / CCOND, CCOND / ERRBND( *, cwise_i, cond_i )).
B: Test ratio is set to 1 / (EPS * ERRBND( *, cwise_i, cond_i )).
.. Parameters ..
NMAX is determined by the largest number in the inverse of the hilbert
matrix. Precision is exhausted when the largest entry in it is greater
than 2 to the power of the number of bits in the fraction of the data
type used plus one, which is 24 for single precision.
NMAX should be 6 for single and 11 for double.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrab (integer NUNIT)
ZERRAB
Purpose:
DERRAB tests the error exits for ZCGESV.
Parameters:
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrac (integer NUNIT)
ZERRAC
Purpose:
ZERRPX tests the error exits for ZCPOSV.
Parameters:
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrge (character*3 PATH, integer NUNIT)
ZERRGE ZERRGEX
Purpose:
ZERRGE tests the error exits for the COMPLEX*16 routines
for general matrices.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
Purpose:
ZERRGE tests the error exits for the COMPLEX*16 routines
for general matrices.
Note that this file is used only when the XBLAS are available,
otherwise zerrge.f defines this subroutine.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrgt (character*3 PATH, integer NUNIT)
ZERRGT
Purpose:
ZERRGT tests the error exits for the COMPLEX*16 tridiagonal
routines.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrhe (character*3 PATH, integer NUNIT)
ZERRHE ZERRHEX
Purpose:
ZERRHE tests the error exits for the COMPLEX*16 routines
for Hermitian indefinite matrices.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
Purpose:
ZERRHE tests the error exits for the COMPLEX*16 routines
for Hermitian indefinite matrices.
Note that this file is used only when the XBLAS are available,
otherwise zerrhe.f defines this subroutine.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zerrlq (character*3 PATH, integer NUNIT)
ZERRLQ
Purpose:
ZERRLQ tests the error exits for the COMPLEX*16 routines
that use the LQ decomposition of a general matrix.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrls (character*3 PATH, integer NUNIT)
ZERRLS
Purpose:
ZERRLS tests the error exits for the COMPLEX*16 least squares
driver routines (ZGELS, CGELSS, CGELSY, CGELSD).
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zerrpo (character*3 PATH, integer NUNIT)
ZERRPO ZERRPOX
Purpose:
ZERRPO tests the error exits for the COMPLEX*16 routines
for Hermitian positive definite matrices.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
Purpose:
ZERRPO tests the error exits for the COMPLEX*16 routines
for Hermitian positive definite matrices.
Note that this file is used only when the XBLAS are available,
otherwise zerrpo.f defines this subroutine.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zerrps (character*3 PATH, integer NUNIT)
ZERRPS
Purpose:
ZERRPS tests the error exits for the COMPLEX routines
for ZPSTRF.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrql (character*3 PATH, integer NUNIT)
ZERRQL
Purpose:
ZERRQL tests the error exits for the COMPLEX*16 routines
that use the QL decomposition of a general matrix.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrqp (character*3 PATH, integer NUNIT)
ZERRQP
Purpose:
ZERRQP tests the error exits for ZGEQP3.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zerrqr (character*3 PATH, integer NUNIT)
ZERRQR
Purpose:
ZERRQR tests the error exits for the COMPLEX*16 routines
that use the QR decomposition of a general matrix.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrqrt (character*3 PATH, integer NUNIT)
ZERRQRT
Purpose:
ZERRQRT tests the error exits for the COMPLEX*16 routines
that use the QRT decomposition of a general matrix.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrqrtp (character*3 PATH, integer NUNIT)
ZERRQRTP
Purpose:
ZERRQRTP tests the error exits for the COMPLEX*16 routines
that use the QRT decomposition of a triangular-pentagonal matrix.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrrfp (integer NUNIT)
ZERRRFP
Purpose:
ZERRRFP tests the error exits for the COMPLEX*16 driver routines
for solving linear systems of equations.
ZDRVRFP tests the COMPLEX*16 LAPACK RFP routines:
ZTFSM, ZTFTRI, ZHFRK, ZTFTTP, ZTFTTR, ZPFTRF, ZPFTRS, ZTPTTF,
ZTPTTR, ZTRTTF, and ZTRTTP
Parameters:
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrrq (character*3 PATH, integer NUNIT)
ZERRRQ
Purpose:
ZERRRQ tests the error exits for the COMPLEX*16 routines
that use the RQ decomposition of a general matrix.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrsy (character*3 PATH, integer NUNIT)
ZERRSY ZERRSYX
Purpose:
ZERRSY tests the error exits for the COMPLEX*16 routines
for symmetric indefinite matrices.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
Purpose:
ZERRSY tests the error exits for the COMPLEX*16 routines
for symmetric indefinite matrices.
Note that this file is used only when the XBLAS are available,
otherwise zerrsy.f defines this subroutine.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zerrtr (character*3 PATH, integer NUNIT)
ZERRTR
Purpose:
ZERRTR tests the error exits for the COMPLEX*16 triangular routines.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zerrtz (character*3 PATH, integer NUNIT)
ZERRTZ
Purpose:
ZERRTZ tests the error exits for ZTZRZF.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zerrvx (character*3 PATH, integer NUNIT)
ZERRVX ZERRVXX
Purpose:
ZERRVX tests the error exits for the COMPLEX*16 driver routines
for solving linear systems of equations.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
Purpose:
ZERRVX tests the error exits for the COMPLEX*16 driver routines
for solving linear systems of equations.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name for the routines to be tested.
NUNIT
NUNIT is INTEGER
The unit number for output.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zgbt01 (integer M, integer N, integer KL, integer KU, complex*16, dimension( lda, *
) A, integer LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer,
dimension( * ) IPIV, complex*16, dimension( * ) WORK, double precision RESID)
ZGBT01
Purpose:
ZGBT01 reconstructs a band matrix A from its L*U factorization and
computes the residual:
norm(L*U - A) / ( N * norm(A) * EPS ),
where EPS is the machine epsilon.
The expression L*U - A is computed one column at a time, so A and
AFAC are not modified.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
KL
KL is INTEGER
The number of subdiagonals within the band of A. KL >= 0.
KU
KU is INTEGER
The number of superdiagonals within the band of A. KU >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original matrix A in band storage, stored in rows 1 to
KL+KU+1.
LDA
LDA is INTEGER.
The leading dimension of the array A. LDA >= max(1,KL+KU+1).
AFAC
AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
The factored form of the matrix A. AFAC contains the banded
factors L and U from the L*U factorization, as computed by
ZGBTRF. U is stored as an upper triangular band matrix with
KL+KU superdiagonals in rows 1 to KL+KU+1, and the
multipliers used during the factorization are stored in rows
KL+KU+2 to 2*KL+KU+1. See ZGBTRF for further details.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC.
LDAFAC >= max(1,2*KL*KU+1).
IPIV
IPIV is INTEGER array, dimension (min(M,N))
The pivot indices from ZGBTRF.
WORK
WORK is COMPLEX*16 array, dimension (2*KL+KU+1)
RESID
RESID is DOUBLE PRECISION
norm(L*U - A) / ( N * norm(A) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zgbt02 (character TRANS, integer M, integer N, integer KL, integer KU, integer
NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X,
integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision RESID)
ZGBT02
Purpose:
ZGBT02 computes the residual for a solution of a banded system of
equations A*x = b or A'*x = b:
RESID = norm( B - A*X ) / ( norm(A) * norm(X) * EPS).
where EPS is the machine precision.
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations:
= 'N': A *x = b
= 'T': A'*x = b, where A' is the transpose of A
= 'C': A'*x = b, where A' is the transpose of A
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
KL
KL is INTEGER
The number of subdiagonals within the band of A. KL >= 0.
KU
KU is INTEGER
The number of superdiagonals within the band of A. KU >= 0.
NRHS
NRHS is INTEGER
The number of columns of B. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original matrix A in band storage, stored in rows 1 to
KL+KU+1.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,KL+KU+1).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. If TRANS = 'N',
LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side vectors for the system of
linear equations.
On exit, B is overwritten with the difference B - A*X.
LDB
LDB is INTEGER
The leading dimension of the array B. IF TRANS = 'N',
LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zgbt05 (character TRANS, integer N, integer KL, integer KU, integer NRHS,
complex*16, dimension( ldab, * ) AB, integer LDAB, complex*16, dimension( ldb, * ) B,
integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension(
ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision,
dimension( * ) BERR, double precision, dimension( * ) RESLTS)
ZGBT05
Purpose:
ZGBT05 tests the error bounds from iterative refinement for the
computed solution to a system of equations op(A)*X = B, where A is a
general band matrix of order n with kl subdiagonals and ku
superdiagonals and op(A) = A or A**T, depending on TRANS.
RESLTS(1) = test of the error bound
= norm(X - XACT) / ( norm(X) * FERR )
A large value is returned if this ratio is not less than one.
RESLTS(2) = residual from the iterative refinement routine
= the maximum of BERR / ( NZ*EPS + (*) ), where
(*) = NZ*UNFL / (min_i (abs(op(A))*abs(X) +abs(b))_i )
and NZ = max. number of nonzeros in any row of A, plus 1
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations.
= 'N': A * X = B (No transpose)
= 'T': A**T * X = B (Transpose)
= 'C': A**H * X = B (Conjugate transpose = Transpose)
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
KL
KL is INTEGER
The number of subdiagonals within the band of A. KL >= 0.
KU
KU is INTEGER
The number of superdiagonals within the band of A. KU >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
AB
AB is COMPLEX*16 array, dimension (LDAB,N)
The original band matrix A, stored in rows 1 to KL+KU+1.
The j-th column of A is stored in the j-th column of the
array AB as follows:
AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(n,j+kl).
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= KL+KU+1.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is COMPLEX*16 array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is DOUBLE PRECISION array, dimension (NRHS)
The estimated forward error bounds for each solution vector
X. If XTRUE is the true solution, FERR bounds the magnitude
of the largest entry in (X - XTRUE) divided by the magnitude
of the largest entry in X.
BERR
BERR is DOUBLE PRECISION array, dimension (NRHS)
The componentwise relative backward error of each solution
vector (i.e., the smallest relative change in any entry of A
or B that makes X an exact solution).
RESLTS
RESLTS is DOUBLE PRECISION array, dimension (2)
The maximum over the NRHS solution vectors of the ratios:
RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
RESLTS(2) = BERR / ( NZ*EPS + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zgelqs (integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( ldb, * ) B, integer
LDB, complex*16, dimension( lwork ) WORK, integer LWORK, integer INFO)
ZGELQS
Purpose:
Compute a minimum-norm solution
min || A*X - B ||
using the LQ factorization
A = L*Q
computed by ZGELQF.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= M >= 0.
NRHS
NRHS is INTEGER
The number of columns of B. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
Details of the LQ factorization of the original matrix A as
returned by ZGELQF.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= M.
TAU
TAU is COMPLEX*16 array, dimension (M)
Details of the orthogonal matrix Q.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the m-by-nrhs right hand side matrix B.
On exit, the n-by-nrhs solution matrix X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= N.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK must be at least NRHS,
and should be at least NRHS*NB, where NB is the block size
for this environment.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
logical function zgennd (integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA)
ZGENND
Purpose:
ZGENND tests that its argument has a real, non-negative diagonal.
Parameters:
M
M is INTEGER
The number of rows in A.
N
N is INTEGER
The number of columns in A.
A
A is COMPLEX*16 array, dimension (LDA, N)
The matrix.
LDA
LDA is INTEGER
Leading dimension of A.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zgeqls (integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( ldb, * ) B, integer
LDB, complex*16, dimension( lwork ) WORK, integer LWORK, integer INFO)
ZGEQLS
Purpose:
Solve the least squares problem
min || A*X - B ||
using the QL factorization
A = Q*L
computed by ZGEQLF.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. M >= N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
Details of the QL factorization of the original matrix A as
returned by ZGEQLF.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= M.
TAU
TAU is COMPLEX*16 array, dimension (N)
Details of the orthogonal matrix Q.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the m-by-nrhs right hand side matrix B.
On exit, the n-by-nrhs solution matrix X, stored in rows
m-n+1:m.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= M.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK must be at least NRHS,
and should be at least NRHS*NB, where NB is the block size
for this environment.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zgeqrs (integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( ldb, * ) B, integer
LDB, complex*16, dimension( lwork ) WORK, integer LWORK, integer INFO)
ZGEQRS
Purpose:
Solve the least squares problem
min || A*X - B ||
using the QR factorization
A = Q*R
computed by ZGEQRF.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. M >= N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
Details of the QR factorization of the original matrix A as
returned by ZGEQRF.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= M.
TAU
TAU is COMPLEX*16 array, dimension (N)
Details of the orthogonal matrix Q.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the m-by-nrhs right hand side matrix B.
On exit, the n-by-nrhs solution matrix X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= M.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK must be at least NRHS,
and should be at least NRHS*NB, where NB is the block size
for this environment.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zgerqs (integer M, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( ldb, * ) B, integer
LDB, complex*16, dimension( lwork ) WORK, integer LWORK, integer INFO)
ZGERQS
Purpose:
Compute a minimum-norm solution
min || A*X - B ||
using the RQ factorization
A = R*Q
computed by ZGERQF.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= M >= 0.
NRHS
NRHS is INTEGER
The number of columns of B. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
Details of the RQ factorization of the original matrix A as
returned by ZGERQF.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= M.
TAU
TAU is COMPLEX*16 array, dimension (M)
Details of the orthogonal matrix Q.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side vectors for the linear system.
On exit, the solution vectors X. Each solution vector
is contained in rows 1:N of a column of B.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK must be at least NRHS,
and should be at least NRHS*NB, where NB is the block size
for this environment.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zget01 (integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA,
complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * ) IPIV,
double precision, dimension( * ) RWORK, double precision RESID)
ZGET01
Purpose:
ZGET01 reconstructs a matrix A from its L*U factorization and
computes the residual
norm(L*U - A) / ( N * norm(A) * EPS ),
where EPS is the machine epsilon.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original M x N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,M).
AFAC
AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
The factored form of the matrix A. AFAC contains the factors
L and U from the L*U factorization as computed by ZGETRF.
Overwritten with the reconstructed matrix, and then with the
difference L*U - A.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC. LDAFAC >= max(1,M).
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices from ZGETRF.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESID
RESID is DOUBLE PRECISION
norm(L*U - A) / ( N * norm(A) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zget02 (character TRANS, integer M, integer N, integer NRHS, complex*16, dimension(
lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double
precision RESID)
ZGET02
Purpose:
ZGET02 computes the residual for a solution of a system of linear
equations A*x = b or A'*x = b:
RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
where EPS is the machine epsilon.
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations:
= 'N': A *x = b
= 'T': A^T*x = b, where A^T is the transpose of A
= 'C': A^H*x = b, where A^H is the conjugate transpose of A
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B, the matrix of right hand sides.
NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original M x N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,M).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. If TRANS = 'N',
LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side vectors for the system of
linear equations.
On exit, B is overwritten with the difference B - A*X.
LDB
LDB is INTEGER
The leading dimension of the array B. IF TRANS = 'N',
LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zget03 (integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16,
dimension( ldainv, * ) AINV, integer LDAINV, complex*16, dimension( ldwork, * ) WORK,
integer LDWORK, double precision, dimension( * ) RWORK, double precision RCOND, double
precision RESID)
ZGET03
Purpose:
ZGET03 computes the residual for a general matrix times its inverse:
norm( I - AINV*A ) / ( N * norm(A) * norm(AINV) * EPS ),
where EPS is the machine epsilon.
Parameters:
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original N x N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
AINV
AINV is COMPLEX*16 array, dimension (LDAINV,N)
The inverse of the matrix A.
LDAINV
LDAINV is INTEGER
The leading dimension of the array AINV. LDAINV >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (LDWORK,N)
LDWORK
LDWORK is INTEGER
The leading dimension of the array WORK. LDWORK >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RCOND
RCOND is DOUBLE PRECISION
The reciprocal of the condition number of A, computed as
( 1/norm(A) ) / norm(AINV).
RESID
RESID is DOUBLE PRECISION
norm(I - AINV*A) / ( N * norm(A) * norm(AINV) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zget04 (integer N, integer NRHS, complex*16, dimension( ldx, * ) X, integer LDX,
complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision RCOND, double
precision RESID)
ZGET04
Purpose:
ZGET04 computes the difference between a computed solution and the
true solution to a system of linear equations.
RESID = ( norm(X-XACT) * RCOND ) / ( norm(XACT) * EPS ),
where RCOND is the reciprocal of the condition number and EPS is the
machine epsilon.
Parameters:
N
N is INTEGER
The number of rows of the matrices X and XACT. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X and XACT. NRHS >= 0.
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is COMPLEX*16 array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
RCOND
RCOND is DOUBLE PRECISION
The reciprocal of the condition number of the coefficient
matrix in the system of equations.
RESID
RESID is DOUBLE PRECISION
The maximum over the NRHS solution vectors of
( norm(X-XACT) * RCOND ) / ( norm(XACT) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zget07 (character TRANS, integer N, integer NRHS, complex*16, dimension( lda, * )
A, integer LDA, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension(
ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double
precision, dimension( * ) FERR, logical CHKFERR, double precision, dimension( * ) BERR,
double precision, dimension( * ) RESLTS)
ZGET07
Purpose:
ZGET07 tests the error bounds from iterative refinement for the
computed solution to a system of equations op(A)*X = B, where A is a
general n by n matrix and op(A) = A or A**T, depending on TRANS.
RESLTS(1) = test of the error bound
= norm(X - XACT) / ( norm(X) * FERR )
A large value is returned if this ratio is not less than one.
RESLTS(2) = residual from the iterative refinement routine
= the maximum of BERR / ( (n+1)*EPS + (*) ), where
(*) = (n+1)*UNFL / (min_i (abs(op(A))*abs(X) +abs(b))_i )
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations.
= 'N': A * X = B (No transpose)
= 'T': A**T * X = B (Transpose)
= 'C': A**H * X = B (Conjugate transpose = Transpose)
N
N is INTEGER
The number of rows of the matrices X and XACT. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X and XACT. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original n by n matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is COMPLEX*16 array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is DOUBLE PRECISION array, dimension (NRHS)
The estimated forward error bounds for each solution vector
X. If XTRUE is the true solution, FERR bounds the magnitude
of the largest entry in (X - XTRUE) divided by the magnitude
of the largest entry in X.
CHKFERR
CHKFERR is LOGICAL
Set to .TRUE. to check FERR, .FALSE. not to check FERR.
When the test system is ill-conditioned, the "true"
solution in XACT may be incorrect.
BERR
BERR is DOUBLE PRECISION array, dimension (NRHS)
The componentwise relative backward error of each solution
vector (i.e., the smallest relative change in any entry of A
or B that makes X an exact solution).
RESLTS
RESLTS is DOUBLE PRECISION array, dimension (2)
The maximum over the NRHS solution vectors of the ratios:
RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
RESLTS(2) = BERR / ( (n+1)*EPS + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zget08 (character TRANS, integer M, integer N, integer NRHS, complex*16, dimension(
lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double
precision RESID)
ZGET08
Purpose:
ZGET08 computes the residual for a solution of a system of linear
equations A*x = b or A'*x = b:
RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
where EPS is the machine epsilon.
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations:
= 'N': A *x = b
= 'T': A^T*x = b, where A^T is the transpose of A
= 'C': A^H*x = b, where A^H is the conjugate transpose of A
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B, the matrix of right hand sides.
NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original M x N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,M).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. If TRANS = 'N',
LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side vectors for the system of
linear equations.
On exit, B is overwritten with the difference B - A*X.
LDB
LDB is INTEGER
The leading dimension of the array B. IF TRANS = 'N',
LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zgtt01 (integer N, complex*16, dimension( * ) DL, complex*16, dimension( * ) D,
complex*16, dimension( * ) DU, complex*16, dimension( * ) DLF, complex*16, dimension( * )
DF, complex*16, dimension( * ) DUF, complex*16, dimension( * ) DU2, integer, dimension( *
) IPIV, complex*16, dimension( ldwork, * ) WORK, integer LDWORK, double precision,
dimension( * ) RWORK, double precision RESID)
ZGTT01
Purpose:
ZGTT01 reconstructs a tridiagonal matrix A from its LU factorization
and computes the residual
norm(L*U - A) / ( norm(A) * EPS ),
where EPS is the machine epsilon.
Parameters:
N
N is INTEGTER
The order of the matrix A. N >= 0.
DL
DL is COMPLEX*16 array, dimension (N-1)
The (n-1) sub-diagonal elements of A.
D
D is COMPLEX*16 array, dimension (N)
The diagonal elements of A.
DU
DU is COMPLEX*16 array, dimension (N-1)
The (n-1) super-diagonal elements of A.
DLF
DLF is COMPLEX*16 array, dimension (N-1)
The (n-1) multipliers that define the matrix L from the
LU factorization of A.
DF
DF is COMPLEX*16 array, dimension (N)
The n diagonal elements of the upper triangular matrix U from
the LU factorization of A.
DUF
DUF is COMPLEX*16 array, dimension (N-1)
The (n-1) elements of the first super-diagonal of U.
DU2
DU2 is COMPLEX*16 array, dimension (N-2)
The (n-2) elements of the second super-diagonal of U.
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices; for 1 <= i <= n, row i of the matrix was
interchanged with row IPIV(i). IPIV(i) will always be either
i or i+1; IPIV(i) = i indicates a row interchange was not
required.
WORK
WORK is COMPLEX*16 array, dimension (LDWORK,N)
LDWORK
LDWORK is INTEGER
The leading dimension of the array WORK. LDWORK >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
The scaled residual: norm(L*U - A) / (norm(A) * EPS)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zgtt02 (character TRANS, integer N, integer NRHS, complex*16, dimension( * ) DL,
complex*16, dimension( * ) D, complex*16, dimension( * ) DU, complex*16, dimension( ldx, *
) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, double precision RESID)
ZGTT02
Purpose:
ZGTT02 computes the residual for the solution to a tridiagonal
system of equations:
RESID = norm(B - op(A)*X) / (norm(A) * norm(X) * EPS),
where EPS is the machine epsilon.
Parameters:
TRANS
TRANS is CHARACTER
Specifies the form of the residual.
= 'N': B - A * X (No transpose)
= 'T': B - A**T * X (Transpose)
= 'C': B - A**H * X (Conjugate transpose)
N
N is INTEGTER
The order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices B and X. NRHS >= 0.
DL
DL is COMPLEX*16 array, dimension (N-1)
The (n-1) sub-diagonal elements of A.
D
D is COMPLEX*16 array, dimension (N)
The diagonal elements of A.
DU
DU is COMPLEX*16 array, dimension (N-1)
The (n-1) super-diagonal elements of A.
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side vectors for the system of
linear equations.
On exit, B is overwritten with the difference B - op(A)*X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
RESID
RESID is DOUBLE PRECISION
norm(B - op(A)*X) / (norm(A) * norm(X) * EPS)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zgtt05 (character TRANS, integer N, integer NRHS, complex*16, dimension( * ) DL,
complex*16, dimension( * ) D, complex*16, dimension( * ) DU, complex*16, dimension( ldb, *
) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension(
ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision,
dimension( * ) BERR, double precision, dimension( * ) RESLTS)
ZGTT05
Purpose:
ZGTT05 tests the error bounds from iterative refinement for the
computed solution to a system of equations A*X = B, where A is a
general tridiagonal matrix of order n and op(A) = A or A**T,
depending on TRANS.
RESLTS(1) = test of the error bound
= norm(X - XACT) / ( norm(X) * FERR )
A large value is returned if this ratio is not less than one.
RESLTS(2) = residual from the iterative refinement routine
= the maximum of BERR / ( NZ*EPS + (*) ), where
(*) = NZ*UNFL / (min_i (abs(op(A))*abs(X) +abs(b))_i )
and NZ = max. number of nonzeros in any row of A, plus 1
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations.
= 'N': A * X = B (No transpose)
= 'T': A**T * X = B (Transpose)
= 'C': A**H * X = B (Conjugate transpose = Transpose)
N
N is INTEGER
The number of rows of the matrices X and XACT. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X and XACT. NRHS >= 0.
DL
DL is COMPLEX*16 array, dimension (N-1)
The (n-1) sub-diagonal elements of A.
D
D is COMPLEX*16 array, dimension (N)
The diagonal elements of A.
DU
DU is COMPLEX*16 array, dimension (N-1)
The (n-1) super-diagonal elements of A.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is COMPLEX*16 array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is DOUBLE PRECISION array, dimension (NRHS)
The estimated forward error bounds for each solution vector
X. If XTRUE is the true solution, FERR bounds the magnitude
of the largest entry in (X - XTRUE) divided by the magnitude
of the largest entry in X.
BERR
BERR is DOUBLE PRECISION array, dimension (NRHS)
The componentwise relative backward error of each solution
vector (i.e., the smallest relative change in any entry of A
or B that makes X an exact solution).
RESLTS
RESLTS is DOUBLE PRECISION array, dimension (2)
The maximum over the NRHS solution vectors of the ratios:
RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
RESLTS(2) = BERR / ( NZ*EPS + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zhet01 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA,
complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * ) IPIV,
complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) RWORK,
double precision RESID)
ZHET01
Purpose:
ZHET01 reconstructs a Hermitian indefinite matrix A from its
block L*D*L' or U*D*U' factorization and computes the residual
norm( C - A ) / ( N * norm(A) * EPS ),
where C is the reconstructed matrix, EPS is the machine epsilon,
L' is the conjugate transpose of L, and U' is the conjugate transpose
of U.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original Hermitian matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
AFAC
AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
The factored form of the matrix A. AFAC contains the block
diagonal matrix D and the multipliers used to obtain the
factor L or U from the block L*D*L' or U*D*U' factorization
as computed by ZHETRF.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC. LDAFAC >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices from ZHETRF.
C
C is COMPLEX*16 array, dimension (LDC,N)
LDC
LDC is INTEGER
The leading dimension of the array C. LDC >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zhet01_rook (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer
LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * )
IPIV, complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * )
RWORK, double precision RESID)
ZHET01_ROOK
Purpose:
ZHET01_ROOK reconstructs a complex Hermitian indefinite matrix A from its
block L*D*L' or U*D*U' factorization and computes the residual
norm( C - A ) / ( N * norm(A) * EPS ),
where C is the reconstructed matrix, EPS is the machine epsilon,
L' is the transpose of L, and U' is the transpose of U.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
complex Hermitian matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original complex Hermitian matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
AFAC
AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
The factored form of the matrix A. AFAC contains the block
diagonal matrix D and the multipliers used to obtain the
factor L or U from the block L*D*L' or U*D*U' factorization
as computed by CSYTRF_ROOK.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC. LDAFAC >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices from CSYTRF_ROOK.
C
C is COMPLEX*16 array, dimension (LDC,N)
LDC
LDC is INTEGER
The leading dimension of the array C. LDC >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zhpt01 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16,
dimension( * ) AFAC, integer, dimension( * ) IPIV, complex*16, dimension( ldc, * ) C,
integer LDC, double precision, dimension( * ) RWORK, double precision RESID)
ZHPT01
Purpose:
ZHPT01 reconstructs a Hermitian indefinite packed matrix A from its
block L*D*L' or U*D*U' factorization and computes the residual
norm( C - A ) / ( N * norm(A) * EPS ),
where C is the reconstructed matrix, EPS is the machine epsilon,
L' is the conjugate transpose of L, and U' is the conjugate transpose
of U.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (N*(N+1)/2)
The original Hermitian matrix A, stored as a packed
triangular matrix.
AFAC
AFAC is COMPLEX*16 array, dimension (N*(N+1)/2)
The factored form of the matrix A, stored as a packed
triangular matrix. AFAC contains the block diagonal matrix D
and the multipliers used to obtain the factor L or U from the
block L*D*L' or U*D*U' factorization as computed by ZHPTRF.
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices from ZHPTRF.
C
C is COMPLEX*16 array, dimension (LDC,N)
LDC
LDC is INTEGER
The leading dimension of the array C. LDC >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlahilb (integer N, integer NRHS, complex*16, dimension(lda,n) A, integer LDA,
complex*16, dimension(ldx, nrhs) X, integer LDX, complex*16, dimension(ldb, nrhs) B,
integer LDB, double precision, dimension(n) WORK, integer INFO, character*3 PATH)
ZLAHILB
Purpose:
ZLAHILB generates an N by N scaled Hilbert matrix in A along with
NRHS right-hand sides in B and solutions in X such that A*X=B.
The Hilbert matrix is scaled by M = LCM(1, 2, ..., 2*N-1) so that all
entries are integers. The right-hand sides are the first NRHS
columns of M * the identity matrix, and the solutions are the
first NRHS columns of the inverse Hilbert matrix.
The condition number of the Hilbert matrix grows exponentially with
its size, roughly as O(e ** (3.5*N)). Additionally, the inverse
Hilbert matrices beyond a relatively small dimension cannot be
generated exactly without extra precision. Precision is exhausted
when the largest entry in the inverse Hilbert matrix is greater than
2 to the power of the number of bits in the fraction of the data type
used plus one, which is 24 for single precision.
In single, the generated solution is exact for N <= 6 and has
small componentwise error for 7 <= N <= 11.
Parameters:
N
N is INTEGER
The dimension of the matrix A.
NRHS
NRHS is NRHS
The requested number of right-hand sides.
A
A is COMPLEX array, dimension (LDA, N)
The generated scaled Hilbert matrix.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= N.
X
X is COMPLEX array, dimension (LDX, NRHS)
The generated exact solutions. Currently, the first NRHS
columns of the inverse Hilbert matrix.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= N.
B
B is REAL array, dimension (LDB, NRHS)
The generated right-hand sides. Currently, the first NRHS
columns of LCM(1, 2, ..., 2*N-1) * the identity matrix.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= N.
WORK
WORK is REAL array, dimension (N)
INFO
INFO is INTEGER
= 0: successful exit
= 1: N is too large; the data is still generated but may not
be not exact.
< 0: if INFO = -i, the i-th argument had an illegal value
PATH
PATH is CHARACTER*3
The LAPACK path name.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlaipd (integer N, complex*16, dimension( * ) A, integer INDA, integer VINDA)
ZLAIPD
Purpose:
ZLAIPD sets the imaginary part of the diagonal elements of a complex
matrix A to a large value. This is used to test LAPACK routines for
complex Hermitian matrices, which are not supposed to access or use
the imaginary parts of the diagonals.
Parameters:
N
N is INTEGER
The number of diagonal elements of A.
A
A is COMPLEX*16 array, dimension
(1+(N-1)*INDA+(N-2)*VINDA)
On entry, the complex (Hermitian) matrix A.
On exit, the imaginary parts of the diagonal elements are set
to BIGNUM = EPS / SAFMIN, where EPS is the machine epsilon and
SAFMIN is the safe minimum.
INDA
INDA is INTEGER
The increment between A(1) and the next diagonal element of A.
Typical values are
= LDA+1: square matrices with leading dimension LDA
= 2: packed upper triangular matrix, starting at A(1,1)
= N: packed lower triangular matrix, starting at A(1,1)
VINDA
VINDA is INTEGER
The change in the diagonal increment between columns of A.
Typical values are
= 0: no change, the row and column increments in A are fixed
= 1: packed upper triangular matrix
= -1: packed lower triangular matrix
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlaptm (character UPLO, integer N, integer NRHS, double precision ALPHA, double
precision, dimension( * ) D, complex*16, dimension( * ) E, complex*16, dimension( ldx, * )
X, integer LDX, double precision BETA, complex*16, dimension( ldb, * ) B, integer LDB)
ZLAPTM
Purpose:
ZLAPTM multiplies an N by NRHS matrix X by a Hermitian tridiagonal
matrix A and stores the result in a matrix B. The operation has the
form
B := alpha * A * X + beta * B
where alpha may be either 1. or -1. and beta may be 0., 1., or -1.
Parameters:
UPLO
UPLO is CHARACTER
Specifies whether the superdiagonal or the subdiagonal of the
tridiagonal matrix A is stored.
= 'U': Upper, E is the superdiagonal of A.
= 'L': Lower, E is the subdiagonal of A.
N
N is INTEGER
The order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B.
ALPHA
ALPHA is DOUBLE PRECISION
The scalar alpha. ALPHA must be 1. or -1.; otherwise,
it is assumed to be 0.
D
D is DOUBLE PRECISION array, dimension (N)
The n diagonal elements of the tridiagonal matrix A.
E
E is COMPLEX*16 array, dimension (N-1)
The (n-1) subdiagonal or superdiagonal elements of A.
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The N by NRHS matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(N,1).
BETA
BETA is DOUBLE PRECISION
The scalar beta. BETA must be 0., 1., or -1.; otherwise,
it is assumed to be 1.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the N by NRHS matrix B.
On exit, B is overwritten by the matrix expression
B := alpha * A * X + beta * B.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(N,1).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlarhs (character*3 PATH, character XTYPE, character UPLO, character TRANS, integer
M, integer N, integer KL, integer KU, integer NRHS, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, *
) B, integer LDB, integer, dimension( 4 ) ISEED, integer INFO)
ZLARHS
Purpose:
ZLARHS chooses a set of NRHS random solution vectors and sets
up the right hand sides for the linear system
op( A ) * X = B,
where op( A ) may be A, A**T (transpose of A), or A**H (conjugate
transpose of A).
Parameters:
PATH
PATH is CHARACTER*3
The type of the complex matrix A. PATH may be given in any
combination of upper and lower case. Valid paths include
xGE: General m x n matrix
xGB: General banded matrix
xPO: Hermitian positive definite, 2-D storage
xPP: Hermitian positive definite packed
xPB: Hermitian positive definite banded
xHE: Hermitian indefinite, 2-D storage
xHP: Hermitian indefinite packed
xHB: Hermitian indefinite banded
xSY: Symmetric indefinite, 2-D storage
xSP: Symmetric indefinite packed
xSB: Symmetric indefinite banded
xTR: Triangular
xTP: Triangular packed
xTB: Triangular banded
xQR: General m x n matrix
xLQ: General m x n matrix
xQL: General m x n matrix
xRQ: General m x n matrix
where the leading character indicates the precision.
XTYPE
XTYPE is CHARACTER*1
Specifies how the exact solution X will be determined:
= 'N': New solution; generate a random X.
= 'C': Computed; use value of X on entry.
UPLO
UPLO is CHARACTER*1
Used only if A is symmetric or triangular; specifies whether
the upper or lower triangular part of the matrix A is stored.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Used only if A is nonsymmetric; specifies the operation
applied to the matrix A.
= 'N': B := A * X
= 'T': B := A**T * X
= 'C': B := A**H * X
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
KL
KL is INTEGER
Used only if A is a band matrix; specifies the number of
subdiagonals of A if A is a general band matrix or if A is
symmetric or triangular and UPLO = 'L'; specifies the number
of superdiagonals of A if A is symmetric or triangular and
UPLO = 'U'. 0 <= KL <= M-1.
KU
KU is INTEGER
Used only if A is a general band matrix or if A is
triangular.
If PATH = xGB, specifies the number of superdiagonals of A,
and 0 <= KU <= N-1.
If PATH = xTR, xTP, or xTB, specifies whether or not the
matrix has unit diagonal:
= 1: matrix has non-unit diagonal (default)
= 2: matrix has unit diagonal
NRHS
NRHS is INTEGER
The number of right hand side vectors in the system A*X = B.
A
A is COMPLEX*16 array, dimension (LDA,N)
The test matrix whose type is given by PATH.
LDA
LDA is INTEGER
The leading dimension of the array A.
If PATH = xGB, LDA >= KL+KU+1.
If PATH = xPB, xSB, xHB, or xTB, LDA >= KL+1.
Otherwise, LDA >= max(1,M).
X
X is or output) COMPLEX*16 array, dimension (LDX,NRHS)
On entry, if XTYPE = 'C' (for 'Computed'), then X contains
the exact solution to the system of linear equations.
On exit, if XTYPE = 'N' (for 'New'), then X is initialized
with random values.
LDX
LDX is INTEGER
The leading dimension of the array X. If TRANS = 'N',
LDX >= max(1,N); if TRANS = 'T', LDX >= max(1,M).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vector(s) for the system of equations,
computed from B = op(A) * X, where op(A) is determined by
TRANS.
LDB
LDB is INTEGER
The leading dimension of the array B. If TRANS = 'N',
LDB >= max(1,M); if TRANS = 'T', LDB >= max(1,N).
ISEED
ISEED is INTEGER array, dimension (4)
The seed vector for the random number generator (used in
ZLATMS). Modified on exit.
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -k, the k-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlatb4 (character*3 PATH, integer IMAT, integer M, integer N, character TYPE,
integer KL, integer KU, double precision ANORM, integer MODE, double precision CNDNUM,
character DIST)
ZLATB4
Purpose:
ZLATB4 sets parameters for the matrix generator based on the type of
matrix to be generated.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name.
IMAT
IMAT is INTEGER
An integer key describing which matrix to generate for this
path.
M
M is INTEGER
The number of rows in the matrix to be generated.
N
N is INTEGER
The number of columns in the matrix to be generated.
TYPE
TYPE is CHARACTER*1
The type of the matrix to be generated:
= 'S': symmetric matrix
= 'H': Hermitian matrix
= 'P': Hermitian positive (semi)definite matrix
= 'N': nonsymmetric matrix
KL
KL is INTEGER
The lower band width of the matrix to be generated.
KU
KU is INTEGER
The upper band width of the matrix to be generated.
ANORM
ANORM is DOUBLE PRECISION
The desired norm of the matrix to be generated. The diagonal
matrix of singular values or eigenvalues is scaled by this
value.
MODE
MODE is INTEGER
A key indicating how to choose the vector of eigenvalues.
CNDNUM
CNDNUM is DOUBLE PRECISION
The desired condition number.
DIST
DIST is CHARACTER*1
The type of distribution to be used by the random number
generator.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zlatb5 (character*3 PATH, integer IMAT, integer N, character TYPE, integer KL,
integer KU, double precision ANORM, integer MODE, double precision CNDNUM, character DIST)
ZLATB5
Purpose:
ZLATB5 sets parameters for the matrix generator based on the type
of matrix to be generated.
Parameters:
PATH
PATH is CHARACTER*3
The LAPACK path name.
IMAT
IMAT is INTEGER
An integer key describing which matrix to generate for this
path.
N
N is INTEGER
The number of rows and columns in the matrix to be generated.
TYPE
TYPE is CHARACTER*1
The type of the matrix to be generated:
= 'S': symmetric matrix
= 'P': symmetric positive (semi)definite matrix
= 'N': nonsymmetric matrix
KL
KL is INTEGER
The lower band width of the matrix to be generated.
KU
KU is INTEGER
The upper band width of the matrix to be generated.
ANORM
ANORM is DOUBLE PRECISION
The desired norm of the matrix to be generated. The diagonal
matrix of singular values or eigenvalues is scaled by this
value.
MODE
MODE is INTEGER
A key indicating how to choose the vector of eigenvalues.
CNDNUM
CNDNUM is DOUBLE PRECISION
The desired condition number.
DIST
DIST is CHARACTER*1
The type of distribution to be used by the random number
generator.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlatsp (character UPLO, integer N, complex*16, dimension( * ) X, integer,
dimension( * ) ISEED)
ZLATSP
Purpose:
ZLATSP generates a special test matrix for the complex symmetric
(indefinite) factorization for packed matrices. The pivot blocks of
the generated matrix will be in the following order:
2x2 pivot block, non diagonalizable
1x1 pivot block
2x2 pivot block, diagonalizable
(cycle repeats)
A row interchange is required for each non-diagonalizable 2x2 block.
Parameters:
UPLO
UPLO is CHARACTER
Specifies whether the generated matrix is to be upper or
lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The dimension of the matrix to be generated.
X
X is COMPLEX*16 array, dimension (N*(N+1)/2)
The generated matrix in packed storage format. The matrix
consists of 3x3 and 2x2 diagonal blocks which result in the
pivot sequence given above. The matrix outside these
diagonal blocks is zero.
ISEED
ISEED is INTEGER array, dimension (4)
On entry, the seed for the random number generator. The last
of the four integers must be odd. (modified on exit)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlatsy (character UPLO, integer N, complex*16, dimension( ldx, * ) X, integer LDX,
integer, dimension( * ) ISEED)
ZLATSY
Purpose:
ZLATSY generates a special test matrix for the complex symmetric
(indefinite) factorization. The pivot blocks of the generated matrix
will be in the following order:
2x2 pivot block, non diagonalizable
1x1 pivot block
2x2 pivot block, diagonalizable
(cycle repeats)
A row interchange is required for each non-diagonalizable 2x2 block.
Parameters:
UPLO
UPLO is CHARACTER
Specifies whether the generated matrix is to be upper or
lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The dimension of the matrix to be generated.
X
X is COMPLEX*16 array, dimension (LDX,N)
The generated matrix, consisting of 3x3 and 2x2 diagonal
blocks which result in the pivot sequence given above.
The matrix outside of these diagonal blocks is zero.
LDX
LDX is INTEGER
The leading dimension of the array X.
ISEED
ISEED is INTEGER array, dimension (4)
On entry, the seed for the random number generator. The last
of the four integers must be odd. (modified on exit)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlattb (integer IMAT, character UPLO, character TRANS, character DIAG, integer,
dimension( 4 ) ISEED, integer N, integer KD, complex*16, dimension( ldab, * ) AB, integer
LDAB, complex*16, dimension( * ) B, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer INFO)
ZLATTB
Purpose:
ZLATTB generates a triangular test matrix in 2-dimensional storage.
IMAT and UPLO uniquely specify the properties of the test matrix,
which is returned in the array A.
Parameters:
IMAT
IMAT is INTEGER
An integer key describing which matrix to generate for this
path.
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A will be upper or lower
triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies whether the matrix or its transpose will be used.
= 'N': No transpose
= 'T': Transpose
= 'C': Conjugate transpose (= transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
ISEED
ISEED is INTEGER array, dimension (4)
The seed vector for the random number generator (used in
ZLATMS). Modified on exit.
N
N is INTEGER
The order of the matrix to be generated.
KD
KD is INTEGER
The number of superdiagonals or subdiagonals of the banded
triangular matrix A. KD >= 0.
AB
AB is COMPLEX*16 array, dimension (LDAB,N)
The upper or lower triangular banded matrix A, stored in the
first KD+1 rows of AB. Let j be a column of A, 1<=j<=n.
If UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j.
If UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= KD+1.
B
B is COMPLEX*16 array, dimension (N)
WORK
WORK is COMPLEX*16 array, dimension (2*N)
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlattp (integer IMAT, character UPLO, character TRANS, character DIAG, integer,
dimension( 4 ) ISEED, integer N, complex*16, dimension( * ) AP, complex*16, dimension( * )
B, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer INFO)
ZLATTP
Purpose:
ZLATTP generates a triangular test matrix in packed storage.
IMAT and UPLO uniquely specify the properties of the test matrix,
which is returned in the array AP.
Parameters:
IMAT
IMAT is INTEGER
An integer key describing which matrix to generate for this
path.
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A will be upper or lower
triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies whether the matrix or its transpose will be used.
= 'N': No transpose
= 'T': Transpose
= 'C': Conjugate transpose
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
ISEED
ISEED is INTEGER array, dimension (4)
The seed vector for the random number generator (used in
ZLATMS). Modified on exit.
N
N is INTEGER
The order of the matrix to be generated.
AP
AP is COMPLEX*16 array, dimension (N*(N+1)/2)
The upper or lower triangular matrix A, packed columnwise in
a linear array. The j-th column of A is stored in the array
AP as follows:
if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
if UPLO = 'L',
AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.
B
B is COMPLEX*16 array, dimension (N)
The right hand side vector, if IMAT > 10.
WORK
WORK is COMPLEX*16 array, dimension (2*N)
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlattr (integer IMAT, character UPLO, character TRANS, character DIAG, integer,
dimension( 4 ) ISEED, integer N, complex*16, dimension( lda, * ) A, integer LDA,
complex*16, dimension( * ) B, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, integer INFO)
ZLATTR
Purpose:
ZLATTR generates a triangular test matrix in 2-dimensional storage.
IMAT and UPLO uniquely specify the properties of the test matrix,
which is returned in the array A.
Parameters:
IMAT
IMAT is INTEGER
An integer key describing which matrix to generate for this
path.
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A will be upper or lower
triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies whether the matrix or its transpose will be used.
= 'N': No transpose
= 'T': Transpose
= 'C': Conjugate transpose
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
ISEED
ISEED is INTEGER array, dimension (4)
The seed vector for the random number generator (used in
ZLATMS). Modified on exit.
N
N is INTEGER
The order of the matrix to be generated.
A
A is COMPLEX*16 array, dimension (LDA,N)
The triangular matrix A. If UPLO = 'U', the leading N x N
upper triangular part of the array A contains the upper
triangular matrix, and the strictly lower triangular part of
A is not referenced. If UPLO = 'L', the leading N x N lower
triangular part of the array A contains the lower triangular
matrix and the strictly upper triangular part of A is not
referenced.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
B
B is COMPLEX*16 array, dimension (N)
The right hand side vector, if IMAT > 10.
WORK
WORK is COMPLEX*16 array, dimension (2*N)
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlavhe (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
complex*16, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV, complex*16,
dimension( ldb, * ) B, integer LDB, integer INFO)
ZLAVHE
Purpose:
ZLAVHE performs one of the matrix-vector operations
x := A*x or x := A^H*x,
where x is an N element vector and A is one of the factors
from the block U*D*U' or L*D*L' factorization computed by ZHETRF.
If TRANS = 'N', multiplies by U or U * D (or L or L * D)
If TRANS = 'C', multiplies by U' or D * U' (or L' or D * L')
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the factor stored in A is upper or lower
triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation to be performed:
= 'N': x := A*x
= 'C': x := A'*x
DIAG
DIAG is CHARACTER*1
Specifies whether or not the diagonal blocks are unit
matrices. If the diagonal blocks are assumed to be unit,
then A = U or A = L, otherwise A = U*D or A = L*D.
= 'U': Diagonal blocks are assumed to be unit matrices.
= 'N': Diagonal blocks are assumed to be non-unit matrices.
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of vectors
x to be multiplied by A. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The block diagonal matrix D and the multipliers used to
obtain the factor U or L as computed by ZHETRF.
Stored as a 2-D triangular matrix.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
Details of the interchanges and the block structure of D,
as determined by ZHETRF.
If UPLO = 'U':
If IPIV(k) > 0, then rows and columns k and IPIV(k)
were interchanged and D(k,k) is a 1-by-1 diagonal block.
(If IPIV( k ) = k, no interchange was done).
If IPIV(k) = IPIV(k-1) < 0, then rows and
columns k-1 and -IPIV(k) were interchanged,
D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
If UPLO = 'L':
If IPIV(k) > 0, then rows and columns k and IPIV(k)
were interchanged and D(k,k) is a 1-by-1 diagonal block.
(If IPIV( k ) = k, no interchange was done).
If IPIV(k) = IPIV(k+1) < 0, then rows and
columns k+1 and -IPIV(k) were interchanged,
D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, B contains NRHS vectors of length N.
On exit, B is overwritten with the product A * B.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -k, the k-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zlavhe_rook (character UPLO, character TRANS, character DIAG, integer N, integer
NRHS, complex*16, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV,
complex*16, dimension( ldb, * ) B, integer LDB, integer INFO)
ZLAVHE_ROOK
Purpose:
ZLAVHE_ROOK performs one of the matrix-vector operations x := A*x or x := A^H*x, where
x is an N element vector and A is one of the factors from the block U*D*U' or L*D*L'
factorization computed by ZHETRF_ROOK.
If TRANS = 'N', multiplies by U or U * D (or L or L * D) If TRANS = 'C', multiplies by U'
or D * U' (or L' or D * L')
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the factor stored in A is upper or lower
triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation to be performed:
= 'N': x := A*x
= 'C': x := A^H*x
DIAG
DIAG is CHARACTER*1
Specifies whether or not the diagonal blocks are unit
matrices. If the diagonal blocks are assumed to be unit,
then A = U or A = L, otherwise A = U*D or A = L*D.
= 'U': Diagonal blocks are assumed to be unit matrices.
= 'N': Diagonal blocks are assumed to be non-unit matrices.
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of vectors
x to be multiplied by A. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The block diagonal matrix D and the multipliers used to
obtain the factor U or L as computed by ZHETRF_ROOK.
Stored as a 2-D triangular matrix.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
Details of the interchanges and the block structure of D,
as determined by ZHETRF_ROOK.
If UPLO = 'U':
Only the last KB elements of IPIV are set.
If IPIV(k) > 0, then rows and columns k and IPIV(k) were
interchanged and D(k,k) is a 1-by-1 diagonal block.
If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and
columns k and -IPIV(k) were interchanged and rows and
columns k-1 and -IPIV(k-1) were inerchaged,
D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
If UPLO = 'L':
Only the first KB elements of IPIV are set.
If IPIV(k) > 0, then rows and columns k and IPIV(k)
were interchanged and D(k,k) is a 1-by-1 diagonal block.
If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and
columns k and -IPIV(k) were interchanged and rows and
columns k+1 and -IPIV(k+1) were inerchaged,
D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
B
B is COMPLEX array, dimension (LDB,NRHS)
On entry, B contains NRHS vectors of length N.
On exit, B is overwritten with the product A * B.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -k, the k-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zlavhp (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
complex*16, dimension( * ) A, integer, dimension( * ) IPIV, complex*16, dimension( ldb, *
) B, integer LDB, integer INFO)
ZLAVHP
Purpose:
ZLAVHP performs one of the matrix-vector operations
x := A*x or x := A^H*x,
where x is an N element vector and A is one of the factors
from the symmetric factorization computed by ZHPTRF.
ZHPTRF produces a factorization of the form
U * D * U^H or L * D * L^H,
where U (or L) is a product of permutation and unit upper (lower)
triangular matrices, U^H (or L^H) is the conjugate transpose of
U (or L), and D is Hermitian and block diagonal with 1 x 1 and
2 x 2 diagonal blocks. The multipliers for the transformations
and the upper or lower triangular parts of the diagonal blocks
are stored columnwise in packed format in the linear array A.
If TRANS = 'N' or 'n', ZLAVHP multiplies either by U or U * D
(or L or L * D).
If TRANS = 'C' or 'c', ZLAVHP multiplies either by U^H or D * U^H
(or L^H or D * L^H ).
UPLO - CHARACTER*1
On entry, UPLO specifies whether the triangular matrix
stored in A is upper or lower triangular.
UPLO = 'U' or 'u' The matrix is upper triangular.
UPLO = 'L' or 'l' The matrix is lower triangular.
Unchanged on exit.
TRANS - CHARACTER*1
On entry, TRANS specifies the operation to be performed as
follows:
TRANS = 'N' or 'n' x := A*x.
TRANS = 'C' or 'c' x := A^H*x.
Unchanged on exit.
DIAG - CHARACTER*1
On entry, DIAG specifies whether the diagonal blocks are
assumed to be unit matrices, as follows:
DIAG = 'U' or 'u' Diagonal blocks are unit matrices.
DIAG = 'N' or 'n' Diagonal blocks are non-unit.
Unchanged on exit.
N - INTEGER
On entry, N specifies the order of the matrix A.
N must be at least zero.
Unchanged on exit.
NRHS - INTEGER
On entry, NRHS specifies the number of right hand sides,
i.e., the number of vectors x to be multiplied by A.
NRHS must be at least zero.
Unchanged on exit.
A - COMPLEX*16 array, dimension( N*(N+1)/2 )
On entry, A contains a block diagonal matrix and the
multipliers of the transformations used to obtain it,
stored as a packed triangular matrix.
Unchanged on exit.
IPIV - INTEGER array, dimension( N )
On entry, IPIV contains the vector of pivot indices as
determined by ZSPTRF or ZHPTRF.
If IPIV( K ) = K, no interchange was done.
If IPIV( K ) <> K but IPIV( K ) > 0, then row K was inter-
changed with row IPIV( K ) and a 1 x 1 pivot block was used.
If IPIV( K ) < 0 and UPLO = 'U', then row K-1 was exchanged
with row | IPIV( K ) | and a 2 x 2 pivot block was used.
If IPIV( K ) < 0 and UPLO = 'L', then row K+1 was exchanged
with row | IPIV( K ) | and a 2 x 2 pivot block was used.
B - COMPLEX*16 array, dimension( LDB, NRHS )
On entry, B contains NRHS vectors of length N.
On exit, B is overwritten with the product A * B.
LDB - INTEGER
On entry, LDB contains the leading dimension of B as
declared in the calling program. LDB must be at least
max( 1, N ).
Unchanged on exit.
INFO - INTEGER
INFO is the error flag.
On exit, a value of 0 indicates a successful exit.
A negative value, say -K, indicates that the K-th argument
has an illegal value.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlavsp (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
complex*16, dimension( * ) A, integer, dimension( * ) IPIV, complex*16, dimension( ldb, *
) B, integer LDB, integer INFO)
ZLAVSP
Purpose:
ZLAVSP performs one of the matrix-vector operations
x := A*x or x := A^T*x,
where x is an N element vector and A is one of the factors
from the symmetric factorization computed by ZSPTRF.
ZSPTRF produces a factorization of the form
U * D * U^T or L * D * L^T,
where U (or L) is a product of permutation and unit upper (lower)
triangular matrices, U^T (or L^T) is the transpose of
U (or L), and D is symmetric and block diagonal with 1 x 1 and
2 x 2 diagonal blocks. The multipliers for the transformations
and the upper or lower triangular parts of the diagonal blocks
are stored columnwise in packed format in the linear array A.
If TRANS = 'N' or 'n', ZLAVSP multiplies either by U or U * D
(or L or L * D).
If TRANS = 'C' or 'c', ZLAVSP multiplies either by U^T or D * U^T
(or L^T or D * L^T ).
UPLO - CHARACTER*1
On entry, UPLO specifies whether the triangular matrix
stored in A is upper or lower triangular.
UPLO = 'U' or 'u' The matrix is upper triangular.
UPLO = 'L' or 'l' The matrix is lower triangular.
Unchanged on exit.
TRANS - CHARACTER*1
On entry, TRANS specifies the operation to be performed as
follows:
TRANS = 'N' or 'n' x := A*x.
TRANS = 'T' or 't' x := A^T*x.
Unchanged on exit.
DIAG - CHARACTER*1
On entry, DIAG specifies whether the diagonal blocks are
assumed to be unit matrices, as follows:
DIAG = 'U' or 'u' Diagonal blocks are unit matrices.
DIAG = 'N' or 'n' Diagonal blocks are non-unit.
Unchanged on exit.
N - INTEGER
On entry, N specifies the order of the matrix A.
N must be at least zero.
Unchanged on exit.
NRHS - INTEGER
On entry, NRHS specifies the number of right hand sides,
i.e., the number of vectors x to be multiplied by A.
NRHS must be at least zero.
Unchanged on exit.
A - COMPLEX*16 array, dimension( N*(N+1)/2 )
On entry, A contains a block diagonal matrix and the
multipliers of the transformations used to obtain it,
stored as a packed triangular matrix.
Unchanged on exit.
IPIV - INTEGER array, dimension( N )
On entry, IPIV contains the vector of pivot indices as
determined by ZSPTRF.
If IPIV( K ) = K, no interchange was done.
If IPIV( K ) <> K but IPIV( K ) > 0, then row K was inter-
changed with row IPIV( K ) and a 1 x 1 pivot block was used.
If IPIV( K ) < 0 and UPLO = 'U', then row K-1 was exchanged
with row | IPIV( K ) | and a 2 x 2 pivot block was used.
If IPIV( K ) < 0 and UPLO = 'L', then row K+1 was exchanged
with row | IPIV( K ) | and a 2 x 2 pivot block was used.
B - COMPLEX*16 array, dimension( LDB, NRHS )
On entry, B contains NRHS vectors of length N.
On exit, B is overwritten with the product A * B.
LDB - INTEGER
On entry, LDB contains the leading dimension of B as
declared in the calling program. LDB must be at least
max( 1, N ).
Unchanged on exit.
INFO - INTEGER
INFO is the error flag.
On exit, a value of 0 indicates a successful exit.
A negative value, say -K, indicates that the K-th argument
has an illegal value.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlavsy (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
complex*16, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV, complex*16,
dimension( ldb, * ) B, integer LDB, integer INFO)
ZLAVSY
Purpose:
ZLAVSY performs one of the matrix-vector operations
x := A*x or x := A'*x,
where x is an N element vector and A is one of the factors
from the block U*D*U' or L*D*L' factorization computed by ZSYTRF.
If TRANS = 'N', multiplies by U or U * D (or L or L * D)
If TRANS = 'T', multiplies by U' or D * U' (or L' or D * L')
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the factor stored in A is upper or lower
triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation to be performed:
= 'N': x := A*x
= 'T': x := A'*x
DIAG
DIAG is CHARACTER*1
Specifies whether or not the diagonal blocks are unit
matrices. If the diagonal blocks are assumed to be unit,
then A = U or A = L, otherwise A = U*D or A = L*D.
= 'U': Diagonal blocks are assumed to be unit matrices.
= 'N': Diagonal blocks are assumed to be non-unit matrices.
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of vectors
x to be multiplied by A. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The block diagonal matrix D and the multipliers used to
obtain the factor U or L as computed by ZSYTRF.
Stored as a 2-D triangular matrix.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
Details of the interchanges and the block structure of D,
as determined by ZSYTRF.
If UPLO = 'U':
If IPIV(k) > 0, then rows and columns k and IPIV(k)
were interchanged and D(k,k) is a 1-by-1 diagonal block.
(If IPIV( k ) = k, no interchange was done).
If IPIV(k) = IPIV(k-1) < 0, then rows and
columns k-1 and -IPIV(k) were interchanged,
D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
If UPLO = 'L':
If IPIV(k) > 0, then rows and columns k and IPIV(k)
were interchanged and D(k,k) is a 1-by-1 diagonal block.
(If IPIV( k ) = k, no interchange was done).
If IPIV(k) = IPIV(k+1) < 0, then rows and
columns k+1 and -IPIV(k) were interchanged,
D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, B contains NRHS vectors of length N.
On exit, B is overwritten with the product A * B.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -k, the k-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zlavsy_rook (character UPLO, character TRANS, character DIAG, integer N, integer
NRHS, complex*16, dimension( lda, * ) A, integer LDA, integer, dimension( * ) IPIV,
complex*16, dimension( ldb, * ) B, integer LDB, integer INFO)
ZLAVSY_ROOK
Purpose:
ZLAVSY_ROOK performs one of the matrix-vector operations
x := A*x or x := A'*x,
where x is an N element vector and A is one of the factors
from the block U*D*U' or L*D*L' factorization computed by ZSYTRF_ROOK.
If TRANS = 'N', multiplies by U or U * D (or L or L * D)
If TRANS = 'T', multiplies by U' or D * U' (or L' or D * L')
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the factor stored in A is upper or lower
triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation to be performed:
= 'N': x := A*x
= 'T': x := A'*x
DIAG
DIAG is CHARACTER*1
Specifies whether or not the diagonal blocks are unit
matrices. If the diagonal blocks are assumed to be unit,
then A = U or A = L, otherwise A = U*D or A = L*D.
= 'U': Diagonal blocks are assumed to be unit matrices.
= 'N': Diagonal blocks are assumed to be non-unit matrices.
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of vectors
x to be multiplied by A. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The block diagonal matrix D and the multipliers used to
obtain the factor U or L as computed by ZSYTRF_ROOK.
Stored as a 2-D triangular matrix.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
Details of the interchanges and the block structure of D,
as determined by ZSYTRF_ROOK.
If UPLO = 'U':
If IPIV(k) > 0, then rows and columns k and IPIV(k)
were interchanged and D(k,k) is a 1-by-1 diagonal block.
(If IPIV( k ) = k, no interchange was done).
If IPIV(k) < 0 and IPIV(k-1) < 0, then rows and
columns k and -IPIV(k) were interchanged and rows and
columns k-1 and -IPIV(k-1) were inerchaged,
D(k-1:k,k-1:k) is a 2-by-2 diagonal block.
If UPLO = 'L':
If IPIV(k) > 0, then rows and columns k and IPIV(k)
were interchanged and D(k,k) is a 1-by-1 diagonal block.
(If IPIV( k ) = k, no interchange was done).
If IPIV(k) < 0 and IPIV(k+1) < 0, then rows and
columns k and -IPIV(k) were interchanged and rows and
columns k+1 and -IPIV(k+1) were inerchaged,
D(k:k+1,k:k+1) is a 2-by-2 diagonal block.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, B contains NRHS vectors of length N.
On exit, B is overwritten with the product A * B.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
INFO
INFO is INTEGER
= 0: successful exit
< 0: if INFO = -k, the k-th argument had an illegal value
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zlqt01 (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16,
dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * )
L, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK,
integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * )
RESULT)
ZLQT01
Purpose:
ZLQT01 tests ZGELQF, which computes the LQ factorization of an m-by-n
matrix A, and partially tests ZUNGLQ which forms the n-by-n
orthogonal matrix Q.
ZLQT01 compares L with A*Q', and checks that Q is orthogonal.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The m-by-n matrix A.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the LQ factorization of A, as returned by ZGELQF.
See ZGELQF for further details.
Q
Q is COMPLEX*16 array, dimension (LDA,N)
The n-by-n orthogonal matrix Q.
L
L is COMPLEX*16 array, dimension (LDA,max(M,N))
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and L.
LDA >= max(M,N).
TAU
TAU is COMPLEX*16 array, dimension (min(M,N))
The scalar factors of the elementary reflectors, as returned
by ZGELQF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is DOUBLE PRECISION array, dimension (max(M,N))
RESULT
RESULT is DOUBLE PRECISION array, dimension (2)
The test ratios:
RESULT(1) = norm( L - A*Q' ) / ( N * norm(A) * EPS )
RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlqt02 (integer M, integer N, integer K, complex*16, dimension( lda, * ) A,
complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16,
dimension( lda, * ) L, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
dimension( * ) RESULT)
ZLQT02
Purpose:
ZLQT02 tests ZUNGLQ, which generates an m-by-n matrix Q with
orthonornmal rows that is defined as the product of k elementary
reflectors.
Given the LQ factorization of an m-by-n matrix A, ZLQT02 generates
the orthogonal matrix Q defined by the factorization of the first k
rows of A; it compares L(1:k,1:m) with A(1:k,1:n)*Q(1:m,1:n)', and
checks that the rows of Q are orthonormal.
Parameters:
M
M is INTEGER
The number of rows of the matrix Q to be generated. M >= 0.
N
N is INTEGER
The number of columns of the matrix Q to be generated.
N >= M >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
matrix Q. M >= K >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The m-by-n matrix A which was factorized by ZLQT01.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the LQ factorization of A, as returned by ZGELQF.
See ZGELQF for further details.
Q
Q is COMPLEX*16 array, dimension (LDA,N)
L
L is COMPLEX*16 array, dimension (LDA,M)
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and L. LDA >= N.
TAU
TAU is COMPLEX*16 array, dimension (M)
The scalar factors of the elementary reflectors corresponding
to the LQ factorization in AF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT is DOUBLE PRECISION array, dimension (2)
The test ratios:
RESULT(1) = norm( L - A*Q' ) / ( N * norm(A) * EPS )
RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zlqt03 (integer M, integer N, integer K, complex*16, dimension( lda, * ) AF,
complex*16, dimension( lda, * ) C, complex*16, dimension( lda, * ) CC, complex*16,
dimension( lda, * ) Q, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
dimension( * ) RESULT)
ZLQT03
Purpose:
ZLQT03 tests ZUNMLQ, which computes Q*C, Q'*C, C*Q or C*Q'.
ZLQT03 compares the results of a call to ZUNMLQ with the results of
forming Q explicitly by a call to ZUNGLQ and then performing matrix
multiplication by a call to ZGEMM.
Parameters:
M
M is INTEGER
The number of rows or columns of the matrix C; C is n-by-m if
Q is applied from the left, or m-by-n if Q is applied from
the right. M >= 0.
N
N is INTEGER
The order of the orthogonal matrix Q. N >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
orthogonal matrix Q. N >= K >= 0.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the LQ factorization of an m-by-n matrix, as
returned by ZGELQF. See CGELQF for further details.
C
C is COMPLEX*16 array, dimension (LDA,N)
CC
CC is COMPLEX*16 array, dimension (LDA,N)
Q
Q is COMPLEX*16 array, dimension (LDA,N)
LDA
LDA is INTEGER
The leading dimension of the arrays AF, C, CC, and Q.
TAU
TAU is COMPLEX*16 array, dimension (min(M,N))
The scalar factors of the elementary reflectors corresponding
to the LQ factorization in AF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of WORK. LWORK must be at least M, and should be
M*NB, where NB is the blocksize for this environment.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT is DOUBLE PRECISION array, dimension (4)
The test ratios compare two techniques for multiplying a
random matrix C by an n-by-n orthogonal matrix Q.
RESULT(1) = norm( Q*C - Q*C ) / ( N * norm(C) * EPS )
RESULT(2) = norm( C*Q - C*Q ) / ( N * norm(C) * EPS )
RESULT(3) = norm( Q'*C - Q'*C )/ ( N * norm(C) * EPS )
RESULT(4) = norm( C*Q' - C*Q' )/ ( N * norm(C) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zpbt01 (character UPLO, integer N, integer KD, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, double precision,
dimension( * ) RWORK, double precision RESID)
ZPBT01
Purpose:
ZPBT01 reconstructs a Hermitian positive definite band matrix A from
its L*L' or U'*U factorization and computes the residual
norm( L*L' - A ) / ( N * norm(A) * EPS ) or
norm( U'*U - A ) / ( N * norm(A) * EPS ),
where EPS is the machine epsilon, L' is the conjugate transpose of
L, and U' is the conjugate transpose of U.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
KD
KD is INTEGER
The number of super-diagonals of the matrix A if UPLO = 'U',
or the number of sub-diagonals if UPLO = 'L'. KD >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original Hermitian band matrix A. If UPLO = 'U', the
upper triangular part of A is stored as a band matrix; if
UPLO = 'L', the lower triangular part of A is stored. The
columns of the appropriate triangle are stored in the columns
of A and the diagonals of the triangle are stored in the rows
of A. See ZPBTRF for further details.
LDA
LDA is INTEGER.
The leading dimension of the array A. LDA >= max(1,KD+1).
AFAC
AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
The factored form of the matrix A. AFAC contains the factor
L or U from the L*L' or U'*U factorization in band storage
format, as computed by ZPBTRF.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC.
LDAFAC >= max(1,KD+1).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS )
If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zpbt02 (character UPLO, integer N, integer KD, integer NRHS, complex*16, dimension(
lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double
precision RESID)
ZPBT02
Purpose:
ZPBT02 computes the residual for a solution of a Hermitian banded
system of equations A*x = b:
RESID = norm( B - A*X ) / ( norm(A) * norm(X) * EPS)
where EPS is the machine precision.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
KD
KD is INTEGER
The number of super-diagonals of the matrix A if UPLO = 'U',
or the number of sub-diagonals if UPLO = 'L'. KD >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original Hermitian band matrix A. If UPLO = 'U', the
upper triangular part of A is stored as a band matrix; if
UPLO = 'L', the lower triangular part of A is stored. The
columns of the appropriate triangle are stored in the columns
of A and the diagonals of the triangle are stored in the rows
of A. See ZPBTRF for further details.
LDA
LDA is INTEGER.
The leading dimension of the array A. LDA >= max(1,KD+1).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side vectors for the system of
linear equations.
On exit, B is overwritten with the difference B - A*X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zpbt05 (character UPLO, integer N, integer KD, integer NRHS, complex*16, dimension(
ldab, * ) AB, integer LDAB, complex*16, dimension( ldb, * ) B, integer LDB, complex*16,
dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer
LDXACT, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR,
double precision, dimension( * ) RESLTS)
ZPBT05
Purpose:
ZPBT05 tests the error bounds from iterative refinement for the
computed solution to a system of equations A*X = B, where A is a
Hermitian band matrix.
RESLTS(1) = test of the error bound
= norm(X - XACT) / ( norm(X) * FERR )
A large value is returned if this ratio is not less than one.
RESLTS(2) = residual from the iterative refinement routine
= the maximum of BERR / ( NZ*EPS + (*) ), where
(*) = NZ*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
and NZ = max. number of nonzeros in any row of A, plus 1
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored.
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
KD
KD is INTEGER
The number of super-diagonals of the matrix A if UPLO = 'U',
or the number of sub-diagonals if UPLO = 'L'. KD >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
AB
AB is COMPLEX*16 array, dimension (LDAB,N)
The upper or lower triangle of the Hermitian band matrix A,
stored in the first KD+1 rows of the array. The j-th column
of A is stored in the j-th column of the array AB as follows:
if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= KD+1.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is COMPLEX*16 array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is DOUBLE PRECISION array, dimension (NRHS)
The estimated forward error bounds for each solution vector
X. If XTRUE is the true solution, FERR bounds the magnitude
of the largest entry in (X - XTRUE) divided by the magnitude
of the largest entry in X.
BERR
BERR is DOUBLE PRECISION array, dimension (NRHS)
The componentwise relative backward error of each solution
vector (i.e., the smallest relative change in any entry of A
or B that makes X an exact solution).
RESLTS
RESLTS is DOUBLE PRECISION array, dimension (2)
The maximum over the NRHS solution vectors of the ratios:
RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
RESLTS(2) = BERR / ( NZ*EPS + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zpot01 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA,
complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, double precision, dimension( * )
RWORK, double precision RESID)
ZPOT01
Purpose:
ZPOT01 reconstructs a Hermitian positive definite matrix A from
its L*L' or U'*U factorization and computes the residual
norm( L*L' - A ) / ( N * norm(A) * EPS ) or
norm( U'*U - A ) / ( N * norm(A) * EPS ),
where EPS is the machine epsilon, L' is the conjugate transpose of L,
and U' is the conjugate transpose of U.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original Hermitian matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
AFAC
AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
On entry, the factor L or U from the L*L' or U'*U
factorization of A.
Overwritten with the reconstructed matrix, and then with the
difference L*L' - A (or U'*U - A).
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC. LDAFAC >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS )
If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zpot02 (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, *
) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)
ZPOT02
Purpose:
ZPOT02 computes the residual for the solution of a Hermitian system
of linear equations A*x = b:
RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
where EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B, the matrix of right hand sides.
NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original Hermitian matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side vectors for the system of
linear equations.
On exit, B is overwritten with the difference B - A*X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zpot03 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA,
complex*16, dimension( ldainv, * ) AINV, integer LDAINV, complex*16, dimension( ldwork, *
) WORK, integer LDWORK, double precision, dimension( * ) RWORK, double precision RCOND,
double precision RESID)
ZPOT03
Purpose:
ZPOT03 computes the residual for a Hermitian matrix times its
inverse:
norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ),
where EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original Hermitian matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
AINV
AINV is COMPLEX*16 array, dimension (LDAINV,N)
On entry, the inverse of the matrix A, stored as a Hermitian
matrix in the same format as A.
In this version, AINV is expanded into a full matrix and
multiplied by A, so the opposing triangle of AINV will be
changed; i.e., if the upper triangular part of AINV is
stored, the lower triangular part will be used as work space.
LDAINV
LDAINV is INTEGER
The leading dimension of the array AINV. LDAINV >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (LDWORK,N)
LDWORK
LDWORK is INTEGER
The leading dimension of the array WORK. LDWORK >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RCOND
RCOND is DOUBLE PRECISION
The reciprocal of the condition number of A, computed as
( 1/norm(A) ) / norm(AINV).
RESID
RESID is DOUBLE PRECISION
norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zpot05 (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, *
) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double
precision, dimension( * ) FERR, double precision, dimension( * ) BERR, double precision,
dimension( * ) RESLTS)
ZPOT05
Purpose:
ZPOT05 tests the error bounds from iterative refinement for the
computed solution to a system of equations A*X = B, where A is a
Hermitian n by n matrix.
RESLTS(1) = test of the error bound
= norm(X - XACT) / ( norm(X) * FERR )
A large value is returned if this ratio is not less than one.
RESLTS(2) = residual from the iterative refinement routine
= the maximum of BERR / ( (n+1)*EPS + (*) ), where
(*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored.
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The Hermitian matrix A. If UPLO = 'U', the leading n by n
upper triangular part of A contains the upper triangular part
of the matrix A, and the strictly lower triangular part of A
is not referenced. If UPLO = 'L', the leading n by n lower
triangular part of A contains the lower triangular part of
the matrix A, and the strictly upper triangular part of A is
not referenced.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is COMPLEX*16 array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is DOUBLE PRECISION array, dimension (NRHS)
The estimated forward error bounds for each solution vector
X. If XTRUE is the true solution, FERR bounds the magnitude
of the largest entry in (X - XTRUE) divided by the magnitude
of the largest entry in X.
BERR
BERR is DOUBLE PRECISION array, dimension (NRHS)
The componentwise relative backward error of each solution
vector (i.e., the smallest relative change in any entry of A
or B that makes X an exact solution).
RESLTS
RESLTS is DOUBLE PRECISION array, dimension (2)
The maximum over the NRHS solution vectors of the ratios:
RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
RESLTS(2) = BERR / ( (n+1)*EPS + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zpot06 (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, *
) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)
ZPOT06
Purpose:
ZPOT06 computes the residual for a solution of a system of linear
equations A*x = b :
RESID = norm(B - A*X,inf) / ( norm(A,inf) * norm(X,inf) * EPS ),
where EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B, the matrix of right hand sides.
NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original M x N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. If TRANS = 'N',
LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side vectors for the system of
linear equations.
On exit, B is overwritten with the difference B - A*X.
LDB
LDB is INTEGER
The leading dimension of the array B. IF TRANS = 'N',
LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zppt01 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16,
dimension( * ) AFAC, double precision, dimension( * ) RWORK, double precision RESID)
ZPPT01
Purpose:
ZPPT01 reconstructs a Hermitian positive definite packed matrix A
from its L*L' or U'*U factorization and computes the residual
norm( L*L' - A ) / ( N * norm(A) * EPS ) or
norm( U'*U - A ) / ( N * norm(A) * EPS ),
where EPS is the machine epsilon, L' is the conjugate transpose of
L, and U' is the conjugate transpose of U.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (N*(N+1)/2)
The original Hermitian matrix A, stored as a packed
triangular matrix.
AFAC
AFAC is COMPLEX*16 array, dimension (N*(N+1)/2)
On entry, the factor L or U from the L*L' or U'*U
factorization of A, stored as a packed triangular matrix.
Overwritten with the reconstructed matrix, and then with the
difference L*L' - A (or U'*U - A).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS )
If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zppt02 (character UPLO, integer N, integer NRHS, complex*16, dimension( * ) A,
complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer
LDB, double precision, dimension( * ) RWORK, double precision RESID)
ZPPT02
Purpose:
ZPPT02 computes the residual in the solution of a Hermitian system
of linear equations A*x = b when packed storage is used for the
coefficient matrix. The ratio computed is
RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS),
where EPS is the machine precision.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B, the matrix of right hand sides.
NRHS >= 0.
A
A is COMPLEX*16 array, dimension (N*(N+1)/2)
The original Hermitian matrix A, stored as a packed
triangular matrix.
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side vectors for the system of
linear equations.
On exit, B is overwritten with the difference B - A*X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zppt03 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16,
dimension( * ) AINV, complex*16, dimension( ldwork, * ) WORK, integer LDWORK, double
precision, dimension( * ) RWORK, double precision RCOND, double precision RESID)
ZPPT03
Purpose:
ZPPT03 computes the residual for a Hermitian packed matrix times its
inverse:
norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ),
where EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (N*(N+1)/2)
The original Hermitian matrix A, stored as a packed
triangular matrix.
AINV
AINV is COMPLEX*16 array, dimension (N*(N+1)/2)
The (Hermitian) inverse of the matrix A, stored as a packed
triangular matrix.
WORK
WORK is COMPLEX*16 array, dimension (LDWORK,N)
LDWORK
LDWORK is INTEGER
The leading dimension of the array WORK. LDWORK >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RCOND
RCOND is DOUBLE PRECISION
The reciprocal of the condition number of A, computed as
( 1/norm(A) ) / norm(AINV).
RESID
RESID is DOUBLE PRECISION
norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zppt05 (character UPLO, integer N, integer NRHS, complex*16, dimension( * ) AP,
complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer
LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension(
* ) FERR, double precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)
ZPPT05
Purpose:
ZPPT05 tests the error bounds from iterative refinement for the
computed solution to a system of equations A*X = B, where A is a
Hermitian matrix in packed storage format.
RESLTS(1) = test of the error bound
= norm(X - XACT) / ( norm(X) * FERR )
A large value is returned if this ratio is not less than one.
RESLTS(2) = residual from the iterative refinement routine
= the maximum of BERR / ( (n+1)*EPS + (*) ), where
(*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored.
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
AP
AP is COMPLEX*16 array, dimension (N*(N+1)/2)
The upper or lower triangle of the Hermitian matrix A, packed
columnwise in a linear array. The j-th column of A is stored
in the array AP as follows:
if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is COMPLEX*16 array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is DOUBLE PRECISION array, dimension (NRHS)
The estimated forward error bounds for each solution vector
X. If XTRUE is the true solution, FERR bounds the magnitude
of the largest entry in (X - XTRUE) divided by the magnitude
of the largest entry in X.
BERR
BERR is DOUBLE PRECISION array, dimension (NRHS)
The componentwise relative backward error of each solution
vector (i.e., the smallest relative change in any entry of A
or B that makes X an exact solution).
RESLTS
RESLTS is DOUBLE PRECISION array, dimension (2)
The maximum over the NRHS solution vectors of the ratios:
RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
RESLTS(2) = BERR / ( (n+1)*EPS + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zpst01 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA,
complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, complex*16, dimension( ldperm, *
) PERM, integer LDPERM, integer, dimension( * ) PIV, double precision, dimension( * )
RWORK, double precision RESID, integer RANK)
ZPST01
Purpose:
ZPST01 reconstructs an Hermitian positive semidefinite matrix A
from its L or U factors and the permutation matrix P and computes
the residual
norm( P*L*L'*P' - A ) / ( N * norm(A) * EPS ) or
norm( P*U'*U*P' - A ) / ( N * norm(A) * EPS ),
where EPS is the machine epsilon, L' is the conjugate transpose of L,
and U' is the conjugate transpose of U.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original Hermitian matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
AFAC
AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
The factor L or U from the L*L' or U'*U
factorization of A.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC. LDAFAC >= max(1,N).
PERM
PERM is COMPLEX*16 array, dimension (LDPERM,N)
Overwritten with the reconstructed matrix, and then with the
difference P*L*L'*P' - A (or P*U'*U*P' - A)
LDPERM
LDPERM is INTEGER
The leading dimension of the array PERM.
LDAPERM >= max(1,N).
PIV
PIV is INTEGER array, dimension (N)
PIV is such that the nonzero entries are
P( PIV( K ), K ) = 1.
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS )
If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )
RANK
RANK is INTEGER
number of nonzero singular values of A.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zptt01 (integer N, double precision, dimension( * ) D, complex*16, dimension( * )
E, double precision, dimension( * ) DF, complex*16, dimension( * ) EF, complex*16,
dimension( * ) WORK, double precision RESID)
ZPTT01
Purpose:
ZPTT01 reconstructs a tridiagonal matrix A from its L*D*L'
factorization and computes the residual
norm(L*D*L' - A) / ( n * norm(A) * EPS ),
where EPS is the machine epsilon.
Parameters:
N
N is INTEGTER
The order of the matrix A.
D
D is DOUBLE PRECISION array, dimension (N)
The n diagonal elements of the tridiagonal matrix A.
E
E is COMPLEX*16 array, dimension (N-1)
The (n-1) subdiagonal elements of the tridiagonal matrix A.
DF
DF is DOUBLE PRECISION array, dimension (N)
The n diagonal elements of the factor L from the L*D*L'
factorization of A.
EF
EF is COMPLEX*16 array, dimension (N-1)
The (n-1) subdiagonal elements of the factor L from the
L*D*L' factorization of A.
WORK
WORK is COMPLEX*16 array, dimension (2*N)
RESID
RESID is DOUBLE PRECISION
norm(L*D*L' - A) / (n * norm(A) * EPS)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zptt02 (character UPLO, integer N, integer NRHS, double precision, dimension( * )
D, complex*16, dimension( * ) E, complex*16, dimension( ldx, * ) X, integer LDX,
complex*16, dimension( ldb, * ) B, integer LDB, double precision RESID)
ZPTT02
Purpose:
ZPTT02 computes the residual for the solution to a symmetric
tridiagonal system of equations:
RESID = norm(B - A*X) / (norm(A) * norm(X) * EPS),
where EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the superdiagonal or the subdiagonal of the
tridiagonal matrix A is stored.
= 'U': E is the superdiagonal of A
= 'L': E is the subdiagonal of A
N
N is INTEGTER
The order of the matrix A.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices B and X. NRHS >= 0.
D
D is DOUBLE PRECISION array, dimension (N)
The n diagonal elements of the tridiagonal matrix A.
E
E is COMPLEX*16 array, dimension (N-1)
The (n-1) subdiagonal elements of the tridiagonal matrix A.
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The n by nrhs matrix of solution vectors X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the n by nrhs matrix of right hand side vectors B.
On exit, B is overwritten with the difference B - A*X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
RESID
RESID is DOUBLE PRECISION
norm(B - A*X) / (norm(A) * norm(X) * EPS)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zptt05 (integer N, integer NRHS, double precision, dimension( * ) D, complex*16,
dimension( * ) E, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension(
ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer LDXACT, double
precision, dimension( * ) FERR, double precision, dimension( * ) BERR, double precision,
dimension( * ) RESLTS)
ZPTT05
Purpose:
ZPTT05 tests the error bounds from iterative refinement for the
computed solution to a system of equations A*X = B, where A is a
Hermitian tridiagonal matrix of order n.
RESLTS(1) = test of the error bound
= norm(X - XACT) / ( norm(X) * FERR )
A large value is returned if this ratio is not less than one.
RESLTS(2) = residual from the iterative refinement routine
= the maximum of BERR / ( NZ*EPS + (*) ), where
(*) = NZ*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
and NZ = max. number of nonzeros in any row of A, plus 1
Parameters:
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
D
D is DOUBLE PRECISION array, dimension (N)
The n diagonal elements of the tridiagonal matrix A.
E
E is COMPLEX*16 array, dimension (N-1)
The (n-1) subdiagonal elements of the tridiagonal matrix A.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is COMPLEX*16 array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is DOUBLE PRECISION array, dimension (NRHS)
The estimated forward error bounds for each solution vector
X. If XTRUE is the true solution, FERR bounds the magnitude
of the largest entry in (X - XTRUE) divided by the magnitude
of the largest entry in X.
BERR
BERR is DOUBLE PRECISION array, dimension (NRHS)
The componentwise relative backward error of each solution
vector (i.e., the smallest relative change in any entry of A
or B that makes X an exact solution).
RESLTS
RESLTS is DOUBLE PRECISION array, dimension (2)
The maximum over the NRHS solution vectors of the ratios:
RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
RESLTS(2) = BERR / ( NZ*EPS + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zqlt01 (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16,
dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * )
L, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK,
integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * )
RESULT)
ZQLT01
Purpose:
ZQLT01 tests ZGEQLF, which computes the QL factorization of an m-by-n
matrix A, and partially tests ZUNGQL which forms the m-by-m
orthogonal matrix Q.
ZQLT01 compares L with Q'*A, and checks that Q is orthogonal.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The m-by-n matrix A.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the QL factorization of A, as returned by ZGEQLF.
See ZGEQLF for further details.
Q
Q is COMPLEX*16 array, dimension (LDA,M)
The m-by-m orthogonal matrix Q.
L
L is COMPLEX*16 array, dimension (LDA,max(M,N))
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and R.
LDA >= max(M,N).
TAU
TAU is COMPLEX*16 array, dimension (min(M,N))
The scalar factors of the elementary reflectors, as returned
by ZGEQLF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT is DOUBLE PRECISION array, dimension (2)
The test ratios:
RESULT(1) = norm( L - Q'*A ) / ( M * norm(A) * EPS )
RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zqlt02 (integer M, integer N, integer K, complex*16, dimension( lda, * ) A,
complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16,
dimension( lda, * ) L, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
dimension( * ) RESULT)
ZQLT02
Purpose:
ZQLT02 tests ZUNGQL, which generates an m-by-n matrix Q with
orthonornmal columns that is defined as the product of k elementary
reflectors.
Given the QL factorization of an m-by-n matrix A, ZQLT02 generates
the orthogonal matrix Q defined by the factorization of the last k
columns of A; it compares L(m-n+1:m,n-k+1:n) with
Q(1:m,m-n+1:m)'*A(1:m,n-k+1:n), and checks that the columns of Q are
orthonormal.
Parameters:
M
M is INTEGER
The number of rows of the matrix Q to be generated. M >= 0.
N
N is INTEGER
The number of columns of the matrix Q to be generated.
M >= N >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
matrix Q. N >= K >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The m-by-n matrix A which was factorized by ZQLT01.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the QL factorization of A, as returned by ZGEQLF.
See ZGEQLF for further details.
Q
Q is COMPLEX*16 array, dimension (LDA,N)
L
L is COMPLEX*16 array, dimension (LDA,N)
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and L. LDA >= M.
TAU
TAU is COMPLEX*16 array, dimension (N)
The scalar factors of the elementary reflectors corresponding
to the QL factorization in AF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT is DOUBLE PRECISION array, dimension (2)
The test ratios:
RESULT(1) = norm( L - Q'*A ) / ( M * norm(A) * EPS )
RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zqlt03 (integer M, integer N, integer K, complex*16, dimension( lda, * ) AF,
complex*16, dimension( lda, * ) C, complex*16, dimension( lda, * ) CC, complex*16,
dimension( lda, * ) Q, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
dimension( * ) RESULT)
ZQLT03
Purpose:
ZQLT03 tests ZUNMQL, which computes Q*C, Q'*C, C*Q or C*Q'.
ZQLT03 compares the results of a call to ZUNMQL with the results of
forming Q explicitly by a call to ZUNGQL and then performing matrix
multiplication by a call to ZGEMM.
Parameters:
M
M is INTEGER
The order of the orthogonal matrix Q. M >= 0.
N
N is INTEGER
The number of rows or columns of the matrix C; C is m-by-n if
Q is applied from the left, or n-by-m if Q is applied from
the right. N >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
orthogonal matrix Q. M >= K >= 0.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the QL factorization of an m-by-n matrix, as
returned by ZGEQLF. See CGEQLF for further details.
C
C is COMPLEX*16 array, dimension (LDA,N)
CC
CC is COMPLEX*16 array, dimension (LDA,N)
Q
Q is COMPLEX*16 array, dimension (LDA,M)
LDA
LDA is INTEGER
The leading dimension of the arrays AF, C, CC, and Q.
TAU
TAU is COMPLEX*16 array, dimension (min(M,N))
The scalar factors of the elementary reflectors corresponding
to the QL factorization in AF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of WORK. LWORK must be at least M, and should be
M*NB, where NB is the blocksize for this environment.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT is DOUBLE PRECISION array, dimension (4)
The test ratios compare two techniques for multiplying a
random matrix C by an m-by-m orthogonal matrix Q.
RESULT(1) = norm( Q*C - Q*C ) / ( M * norm(C) * EPS )
RESULT(2) = norm( C*Q - C*Q ) / ( M * norm(C) * EPS )
RESULT(3) = norm( Q'*C - Q'*C )/ ( M * norm(C) * EPS )
RESULT(4) = norm( C*Q' - C*Q' )/ ( M * norm(C) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
double precision function zqpt01 (integer M, integer N, integer K, complex*16, dimension( lda,
* ) A, complex*16, dimension( lda, * ) AF, integer LDA, complex*16, dimension( * ) TAU,
integer, dimension( * ) JPVT, complex*16, dimension( lwork ) WORK, integer LWORK)
ZQPT01
Purpose:
ZQPT01 tests the QR-factorization with pivoting of a matrix A. The
array AF contains the (possibly partial) QR-factorization of A, where
the upper triangle of AF(1:k,1:k) is a partial triangular factor,
the entries below the diagonal in the first k columns are the
Householder vectors, and the rest of AF contains a partially updated
matrix.
This function returns ||A*P - Q*R||/(||norm(A)||*eps*M)
Parameters:
M
M is INTEGER
The number of rows of the matrices A and AF.
N
N is INTEGER
The number of columns of the matrices A and AF.
K
K is INTEGER
The number of columns of AF that have been reduced
to upper triangular form.
A
A is COMPLEX*16 array, dimension (LDA, N)
The original matrix A.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
The (possibly partial) output of ZGEQPF. The upper triangle
of AF(1:k,1:k) is a partial triangular factor, the entries
below the diagonal in the first k columns are the Householder
vectors, and the rest of AF contains a partially updated
matrix.
LDA
LDA is INTEGER
The leading dimension of the arrays A and AF.
TAU
TAU is COMPLEX*16 array, dimension (K)
Details of the Householder transformations as returned by
ZGEQPF.
JPVT
JPVT is INTEGER array, dimension (N)
Pivot information as returned by ZGEQPF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK >= M*N+N.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zqrt01 (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16,
dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * )
R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK,
integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * )
RESULT)
ZQRT01
Purpose:
ZQRT01 tests ZGEQRF, which computes the QR factorization of an m-by-n
matrix A, and partially tests ZUNGQR which forms the m-by-m
orthogonal matrix Q.
ZQRT01 compares R with Q'*A, and checks that Q is orthogonal.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The m-by-n matrix A.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the QR factorization of A, as returned by ZGEQRF.
See ZGEQRF for further details.
Q
Q is COMPLEX*16 array, dimension (LDA,M)
The m-by-m orthogonal matrix Q.
R
R is COMPLEX*16 array, dimension (LDA,max(M,N))
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and R.
LDA >= max(M,N).
TAU
TAU is COMPLEX*16 array, dimension (min(M,N))
The scalar factors of the elementary reflectors, as returned
by ZGEQRF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT is DOUBLE PRECISION array, dimension (2)
The test ratios:
RESULT(1) = norm( R - Q'*A ) / ( M * norm(A) * EPS )
RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zqrt01p (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16,
dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * )
R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK,
integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * )
RESULT)
ZQRT01P
Purpose:
ZQRT01P tests ZGEQRFP, which computes the QR factorization of an m-by-n
matrix A, and partially tests ZUNGQR which forms the m-by-m
orthogonal matrix Q.
ZQRT01P compares R with Q'*A, and checks that Q is orthogonal.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The m-by-n matrix A.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the QR factorization of A, as returned by ZGEQRFP.
See ZGEQRFP for further details.
Q
Q is COMPLEX*16 array, dimension (LDA,M)
The m-by-m orthogonal matrix Q.
R
R is COMPLEX*16 array, dimension (LDA,max(M,N))
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and R.
LDA >= max(M,N).
TAU
TAU is COMPLEX*16 array, dimension (min(M,N))
The scalar factors of the elementary reflectors, as returned
by ZGEQRFP.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT is DOUBLE PRECISION array, dimension (2)
The test ratios:
RESULT(1) = norm( R - Q'*A ) / ( M * norm(A) * EPS )
RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zqrt02 (integer M, integer N, integer K, complex*16, dimension( lda, * ) A,
complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16,
dimension( lda, * ) R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
dimension( * ) RESULT)
ZQRT02
Purpose:
ZQRT02 tests ZUNGQR, which generates an m-by-n matrix Q with
orthonornmal columns that is defined as the product of k elementary
reflectors.
Given the QR factorization of an m-by-n matrix A, ZQRT02 generates
the orthogonal matrix Q defined by the factorization of the first k
columns of A; it compares R(1:n,1:k) with Q(1:m,1:n)'*A(1:m,1:k),
and checks that the columns of Q are orthonormal.
Parameters:
M
M is INTEGER
The number of rows of the matrix Q to be generated. M >= 0.
N
N is INTEGER
The number of columns of the matrix Q to be generated.
M >= N >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
matrix Q. N >= K >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The m-by-n matrix A which was factorized by ZQRT01.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the QR factorization of A, as returned by ZGEQRF.
See ZGEQRF for further details.
Q
Q is COMPLEX*16 array, dimension (LDA,N)
R
R is COMPLEX*16 array, dimension (LDA,N)
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and R. LDA >= M.
TAU
TAU is COMPLEX*16 array, dimension (N)
The scalar factors of the elementary reflectors corresponding
to the QR factorization in AF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT is DOUBLE PRECISION array, dimension (2)
The test ratios:
RESULT(1) = norm( R - Q'*A ) / ( M * norm(A) * EPS )
RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zqrt03 (integer M, integer N, integer K, complex*16, dimension( lda, * ) AF,
complex*16, dimension( lda, * ) C, complex*16, dimension( lda, * ) CC, complex*16,
dimension( lda, * ) Q, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
dimension( * ) RESULT)
ZQRT03
Purpose:
ZQRT03 tests ZUNMQR, which computes Q*C, Q'*C, C*Q or C*Q'.
ZQRT03 compares the results of a call to ZUNMQR with the results of
forming Q explicitly by a call to ZUNGQR and then performing matrix
multiplication by a call to ZGEMM.
Parameters:
M
M is INTEGER
The order of the orthogonal matrix Q. M >= 0.
N
N is INTEGER
The number of rows or columns of the matrix C; C is m-by-n if
Q is applied from the left, or n-by-m if Q is applied from
the right. N >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
orthogonal matrix Q. M >= K >= 0.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the QR factorization of an m-by-n matrix, as
returned by ZGEQRF. See ZGEQRF for further details.
C
C is COMPLEX*16 array, dimension (LDA,N)
CC
CC is COMPLEX*16 array, dimension (LDA,N)
Q
Q is COMPLEX*16 array, dimension (LDA,M)
LDA
LDA is INTEGER
The leading dimension of the arrays AF, C, CC, and Q.
TAU
TAU is COMPLEX*16 array, dimension (min(M,N))
The scalar factors of the elementary reflectors corresponding
to the QR factorization in AF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of WORK. LWORK must be at least M, and should be
M*NB, where NB is the blocksize for this environment.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT is DOUBLE PRECISION array, dimension (4)
The test ratios compare two techniques for multiplying a
random matrix C by an m-by-m orthogonal matrix Q.
RESULT(1) = norm( Q*C - Q*C ) / ( M * norm(C) * EPS )
RESULT(2) = norm( C*Q - C*Q ) / ( M * norm(C) * EPS )
RESULT(3) = norm( Q'*C - Q'*C )/ ( M * norm(C) * EPS )
RESULT(4) = norm( C*Q' - C*Q' )/ ( M * norm(C) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zqrt04 (integer M, integer N, integer NB, double precision, dimension(6) RESULT)
ZQRT04
Purpose:
ZQRT04 tests ZGEQRT and ZGEMQRT.
Parameters:
M
M is INTEGER
Number of rows in test matrix.
N
N is INTEGER
Number of columns in test matrix.
NB
NB is INTEGER
Block size of test matrix. NB <= Min(M,N).
RESULT
RESULT is DOUBLE PRECISION array, dimension (6)
Results of each of the six tests below.
RESULT(1) = | A - Q R |
RESULT(2) = | I - Q^H Q |
RESULT(3) = | Q C - Q C |
RESULT(4) = | Q^H C - Q^H C |
RESULT(5) = | C Q - C Q |
RESULT(6) = | C Q^H - C Q^H |
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
subroutine zqrt05 (integer M, integer N, integer L, integer NB, double precision, dimension(6)
RESULT)
ZQRT05
Purpose:
ZQRT05 tests ZTPQRT and ZTPMQRT.
Parameters:
M
M is INTEGER
Number of rows in lower part of the test matrix.
N
N is INTEGER
Number of columns in test matrix.
L
L is INTEGER
The number of rows of the upper trapezoidal part the
lower test matrix. 0 <= L <= M.
NB
NB is INTEGER
Block size of test matrix. NB <= N.
RESULT
RESULT is DOUBLE PRECISION array, dimension (6)
Results of each of the six tests below.
RESULT(1) = | A - Q R |
RESULT(2) = | I - Q^H Q |
RESULT(3) = | Q C - Q C |
RESULT(4) = | Q^H C - Q^H C |
RESULT(5) = | C Q - C Q |
RESULT(6) = | C Q^H - C Q^H |
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
April 2012
double precision function zqrt11 (integer M, integer K, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer
LWORK)
ZQRT11
Purpose:
ZQRT11 computes the test ratio
|| Q'*Q - I || / (eps * m)
where the orthogonal matrix Q is represented as a product of
elementary transformations. Each transformation has the form
H(k) = I - tau(k) v(k) v(k)'
where tau(k) is stored in TAU(k) and v(k) is an m-vector of the form
[ 0 ... 0 1 x(k) ]', where x(k) is a vector of length m-k stored
in A(k+1:m,k).
Parameters:
M
M is INTEGER
The number of rows of the matrix A.
K
K is INTEGER
The number of columns of A whose subdiagonal entries
contain information about orthogonal transformations.
A
A is COMPLEX*16 array, dimension (LDA,K)
The (possibly partial) output of a QR reduction routine.
LDA
LDA is INTEGER
The leading dimension of the array A.
TAU
TAU is COMPLEX*16 array, dimension (K)
The scaling factors tau for the elementary transformations as
computed by the QR factorization routine.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK >= M*M + M.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
double precision function zqrt12 (integer M, integer N, complex*16, dimension( lda, * ) A,
integer LDA, double precision, dimension( * ) S, complex*16, dimension( lwork ) WORK,
integer LWORK, double precision, dimension( * ) RWORK)
ZQRT12
Purpose:
ZQRT12 computes the singular values `svlues' of the upper trapezoid
of A(1:M,1:N) and returns the ratio
|| s - svlues||/(||svlues||*eps*max(M,N))
Parameters:
M
M is INTEGER
The number of rows of the matrix A.
N
N is INTEGER
The number of columns of the matrix A.
A
A is COMPLEX*16 array, dimension (LDA,N)
The M-by-N matrix A. Only the upper trapezoid is referenced.
LDA
LDA is INTEGER
The leading dimension of the array A.
S
S is DOUBLE PRECISION array, dimension (min(M,N))
The singular values of the matrix A.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK >= M*N + 2*min(M,N) +
max(M,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (2*min(M,N))
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zqrt13 (integer SCALE, integer M, integer N, complex*16, dimension( lda, * ) A,
integer LDA, double precision NORMA, integer, dimension( 4 ) ISEED)
ZQRT13
Purpose:
ZQRT13 generates a full-rank matrix that may be scaled to have large
or small norm.
Parameters:
SCALE
SCALE is INTEGER
SCALE = 1: normally scaled matrix
SCALE = 2: matrix scaled up
SCALE = 3: matrix scaled down
M
M is INTEGER
The number of rows of the matrix A.
N
N is INTEGER
The number of columns of A.
A
A is COMPLEX*16 array, dimension (LDA,N)
The M-by-N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A.
NORMA
NORMA is DOUBLE PRECISION
The one-norm of A.
ISEED
ISEED is integer array, dimension (4)
Seed for random number generator
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
double precision function zqrt14 (character TRANS, integer M, integer N, integer NRHS,
complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer
LDX, complex*16, dimension( lwork ) WORK, integer LWORK)
ZQRT14
Purpose:
ZQRT14 checks whether X is in the row space of A or A'. It does so
by scaling both X and A such that their norms are in the range
[sqrt(eps), 1/sqrt(eps)], then computing a QR factorization of [A,X]
(if TRANS = 'C') or an LQ factorization of [A',X]' (if TRANS = 'N'),
and returning the norm of the trailing triangle, scaled by
MAX(M,N,NRHS)*eps.
Parameters:
TRANS
TRANS is CHARACTER*1
= 'N': No transpose, check for X in the row space of A
= 'C': Conjugate transpose, check for X in row space of A'.
M
M is INTEGER
The number of rows of the matrix A.
N
N is INTEGER
The number of columns of the matrix A.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of X.
A
A is COMPLEX*16 array, dimension (LDA,N)
The M-by-N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A.
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
If TRANS = 'N', the N-by-NRHS matrix X.
IF TRANS = 'C', the M-by-NRHS matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X.
WORK
WORK is COMPLEX*16 array dimension (LWORK)
LWORK
LWORK is INTEGER
length of workspace array required
If TRANS = 'N', LWORK >= (M+NRHS)*(N+2);
if TRANS = 'C', LWORK >= (N+NRHS)*(M+2).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zqrt15 (integer SCALE, integer RKSEL, integer M, integer N, integer NRHS,
complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B, integer
LDB, double precision, dimension( * ) S, integer RANK, double precision NORMA, double
precision NORMB, integer, dimension( 4 ) ISEED, complex*16, dimension( lwork ) WORK,
integer LWORK)
ZQRT15
Purpose:
ZQRT15 generates a matrix with full or deficient rank and of various
norms.
Parameters:
SCALE
SCALE is INTEGER
SCALE = 1: normally scaled matrix
SCALE = 2: matrix scaled up
SCALE = 3: matrix scaled down
RKSEL
RKSEL is INTEGER
RKSEL = 1: full rank matrix
RKSEL = 2: rank-deficient matrix
M
M is INTEGER
The number of rows of the matrix A.
N
N is INTEGER
The number of columns of A.
NRHS
NRHS is INTEGER
The number of columns of B.
A
A is COMPLEX*16 array, dimension (LDA,N)
The M-by-N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A.
B
B is COMPLEX*16 array, dimension (LDB, NRHS)
A matrix that is in the range space of matrix A.
LDB
LDB is INTEGER
The leading dimension of the array B.
S
S is DOUBLE PRECISION array, dimension MIN(M,N)
Singular values of A.
RANK
RANK is INTEGER
number of nonzero singular values of A.
NORMA
NORMA is DOUBLE PRECISION
one-norm norm of A.
NORMB
NORMB is DOUBLE PRECISION
one-norm norm of B.
ISEED
ISEED is integer array, dimension (4)
seed for random number generator.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
length of work space required.
LWORK >= MAX(M+MIN(M,N),NRHS*MIN(M,N),2*N+M)
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zqrt16 (character TRANS, integer M, integer N, integer NRHS, complex*16, dimension(
lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double
precision RESID)
ZQRT16
Purpose:
ZQRT16 computes the residual for a solution of a system of linear
equations A*x = b or A'*x = b:
RESID = norm(B - A*X) / ( max(m,n) * norm(A) * norm(X) * EPS ),
where EPS is the machine epsilon.
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations:
= 'N': A *x = b
= 'T': A^T*x = b, where A^T is the transpose of A
= 'C': A^H*x = b, where A^H is the conjugate transpose of A
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B, the matrix of right hand sides.
NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original M x N matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,M).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. If TRANS = 'N',
LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side vectors for the system of
linear equations.
On exit, B is overwritten with the difference B - A*X.
LDB
LDB is INTEGER
The leading dimension of the array B. IF TRANS = 'N',
LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(B - A*X) / ( max(m,n) * norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
double precision function zqrt17 (character TRANS, integer IRESID, integer M, integer N,
integer NRHS, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx,
* ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension(
ldb, * ) C, complex*16, dimension( lwork ) WORK, integer LWORK)
ZQRT17
Purpose:
ZQRT17 computes the ratio
|| R'*op(A) ||/(||A||*alpha*max(M,N,NRHS)*eps)
where R = op(A)*X - B, op(A) is A or A', and
alpha = ||B|| if IRESID = 1 (zero-residual problem)
alpha = ||R|| if IRESID = 2 (otherwise).
Parameters:
TRANS
TRANS is CHARACTER*1
Specifies whether or not the transpose of A is used.
= 'N': No transpose, op(A) = A.
= 'C': Conjugate transpose, op(A) = A'.
IRESID
IRESID is INTEGER
IRESID = 1 indicates zero-residual problem.
IRESID = 2 indicates non-zero residual.
M
M is INTEGER
The number of rows of the matrix A.
If TRANS = 'N', the number of rows of the matrix B.
If TRANS = 'C', the number of rows of the matrix X.
N
N is INTEGER
The number of columns of the matrix A.
If TRANS = 'N', the number of rows of the matrix X.
If TRANS = 'C', the number of rows of the matrix B.
NRHS
NRHS is INTEGER
The number of columns of the matrices X and B.
A
A is COMPLEX*16 array, dimension (LDA,N)
The m-by-n matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= M.
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
If TRANS = 'N', the n-by-nrhs matrix X.
If TRANS = 'C', the m-by-nrhs matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X.
If TRANS = 'N', LDX >= N.
If TRANS = 'C', LDX >= M.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
If TRANS = 'N', the m-by-nrhs matrix B.
If TRANS = 'C', the n-by-nrhs matrix B.
LDB
LDB is INTEGER
The leading dimension of the array B.
If TRANS = 'N', LDB >= M.
If TRANS = 'C', LDB >= N.
C
C is COMPLEX*16 array, dimension (LDB,NRHS)
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK >= NRHS*(M+N).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2015
subroutine zrqt01 (integer M, integer N, complex*16, dimension( lda, * ) A, complex*16,
dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16, dimension( lda, * )
R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK,
integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( * )
RESULT)
ZRQT01
Purpose:
ZRQT01 tests ZGERQF, which computes the RQ factorization of an m-by-n
matrix A, and partially tests ZUNGRQ which forms the n-by-n
orthogonal matrix Q.
ZRQT01 compares R with A*Q', and checks that Q is orthogonal.
Parameters:
M
M is INTEGER
The number of rows of the matrix A. M >= 0.
N
N is INTEGER
The number of columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The m-by-n matrix A.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the RQ factorization of A, as returned by ZGERQF.
See ZGERQF for further details.
Q
Q is COMPLEX*16 array, dimension (LDA,N)
The n-by-n orthogonal matrix Q.
R
R is COMPLEX*16 array, dimension (LDA,max(M,N))
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and L.
LDA >= max(M,N).
TAU
TAU is COMPLEX*16 array, dimension (min(M,N))
The scalar factors of the elementary reflectors, as returned
by ZGERQF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is DOUBLE PRECISION array, dimension (max(M,N))
RESULT
RESULT is DOUBLE PRECISION array, dimension (2)
The test ratios:
RESULT(1) = norm( R - A*Q' ) / ( N * norm(A) * EPS )
RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zrqt02 (integer M, integer N, integer K, complex*16, dimension( lda, * ) A,
complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16,
dimension( lda, * ) R, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
dimension( * ) RESULT)
ZRQT02
Purpose:
ZRQT02 tests ZUNGRQ, which generates an m-by-n matrix Q with
orthonornmal rows that is defined as the product of k elementary
reflectors.
Given the RQ factorization of an m-by-n matrix A, ZRQT02 generates
the orthogonal matrix Q defined by the factorization of the last k
rows of A; it compares R(m-k+1:m,n-m+1:n) with
A(m-k+1:m,1:n)*Q(n-m+1:n,1:n)', and checks that the rows of Q are
orthonormal.
Parameters:
M
M is INTEGER
The number of rows of the matrix Q to be generated. M >= 0.
N
N is INTEGER
The number of columns of the matrix Q to be generated.
N >= M >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
matrix Q. M >= K >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The m-by-n matrix A which was factorized by ZRQT01.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the RQ factorization of A, as returned by ZGERQF.
See ZGERQF for further details.
Q
Q is COMPLEX*16 array, dimension (LDA,N)
R
R is COMPLEX*16 array, dimension (LDA,M)
LDA
LDA is INTEGER
The leading dimension of the arrays A, AF, Q and L. LDA >= N.
TAU
TAU is COMPLEX*16 array, dimension (M)
The scalar factors of the elementary reflectors corresponding
to the RQ factorization in AF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The dimension of the array WORK.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT is DOUBLE PRECISION array, dimension (2)
The test ratios:
RESULT(1) = norm( R - A*Q' ) / ( N * norm(A) * EPS )
RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zrqt03 (integer M, integer N, integer K, complex*16, dimension( lda, * ) AF,
complex*16, dimension( lda, * ) C, complex*16, dimension( lda, * ) CC, complex*16,
dimension( lda, * ) Q, integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension(
lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double precision,
dimension( * ) RESULT)
ZRQT03
Purpose:
ZRQT03 tests ZUNMRQ, which computes Q*C, Q'*C, C*Q or C*Q'.
ZRQT03 compares the results of a call to ZUNMRQ with the results of
forming Q explicitly by a call to ZUNGRQ and then performing matrix
multiplication by a call to ZGEMM.
Parameters:
M
M is INTEGER
The number of rows or columns of the matrix C; C is n-by-m if
Q is applied from the left, or m-by-n if Q is applied from
the right. M >= 0.
N
N is INTEGER
The order of the orthogonal matrix Q. N >= 0.
K
K is INTEGER
The number of elementary reflectors whose product defines the
orthogonal matrix Q. N >= K >= 0.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
Details of the RQ factorization of an m-by-n matrix, as
returned by ZGERQF. See CGERQF for further details.
C
C is COMPLEX*16 array, dimension (LDA,N)
CC
CC is COMPLEX*16 array, dimension (LDA,N)
Q
Q is COMPLEX*16 array, dimension (LDA,N)
LDA
LDA is INTEGER
The leading dimension of the arrays AF, C, CC, and Q.
TAU
TAU is COMPLEX*16 array, dimension (min(M,N))
The scalar factors of the elementary reflectors corresponding
to the RQ factorization in AF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of WORK. LWORK must be at least M, and should be
M*NB, where NB is the blocksize for this environment.
RWORK
RWORK is DOUBLE PRECISION array, dimension (M)
RESULT
RESULT is DOUBLE PRECISION array, dimension (4)
The test ratios compare two techniques for multiplying a
random matrix C by an n-by-n orthogonal matrix Q.
RESULT(1) = norm( Q*C - Q*C ) / ( N * norm(C) * EPS )
RESULT(2) = norm( C*Q - C*Q ) / ( N * norm(C) * EPS )
RESULT(3) = norm( Q'*C - Q'*C )/ ( N * norm(C) * EPS )
RESULT(4) = norm( C*Q' - C*Q' )/ ( N * norm(C) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
double precision function zrzt01 (integer M, integer N, complex*16, dimension( lda, * ) A,
complex*16, dimension( lda, * ) AF, integer LDA, complex*16, dimension( * ) TAU,
complex*16, dimension( lwork ) WORK, integer LWORK)
ZRZT01
Purpose:
ZRZT01 returns
|| A - R*Q || / ( M * eps * ||A|| )
for an upper trapezoidal A that was factored with ZTZRZF.
Parameters:
M
M is INTEGER
The number of rows of the matrices A and AF.
N
N is INTEGER
The number of columns of the matrices A and AF.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original upper trapezoidal M by N matrix A.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
The output of ZTZRZF for input matrix A.
The lower triangle is not referenced.
LDA
LDA is INTEGER
The leading dimension of the arrays A and AF.
TAU
TAU is COMPLEX*16 array, dimension (M)
Details of the Householder transformations as returned by
ZTZRZF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
The length of the array WORK. LWORK >= m*n + m.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
double precision function zrzt02 (integer M, integer N, complex*16, dimension( lda, * ) AF,
integer LDA, complex*16, dimension( * ) TAU, complex*16, dimension( lwork ) WORK, integer
LWORK)
ZRZT02
Purpose:
ZRZT02 returns
|| I - Q'*Q || / ( M * eps)
where the matrix Q is defined by the Householder transformations
generated by ZTZRZF.
Parameters:
M
M is INTEGER
The number of rows of the matrix AF.
N
N is INTEGER
The number of columns of the matrix AF.
AF
AF is COMPLEX*16 array, dimension (LDA,N)
The output of ZTZRZF.
LDA
LDA is INTEGER
The leading dimension of the array AF.
TAU
TAU is COMPLEX*16 array, dimension (M)
Details of the Householder transformations as returned by
ZTZRZF.
WORK
WORK is COMPLEX*16 array, dimension (LWORK)
LWORK
LWORK is INTEGER
Length of WORK array. LWORK >= N*N+N.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zsbmv (character UPLO, integer N, integer K, complex*16 ALPHA, complex*16,
dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) X, integer INCX, complex*16
BETA, complex*16, dimension( * ) Y, integer INCY)
ZSBMV
Purpose:
ZSBMV performs the matrix-vector operation
y := alpha*A*x + beta*y,
where alpha and beta are scalars, x and y are n element vectors and
A is an n by n symmetric band matrix, with k super-diagonals.
UPLO - CHARACTER*1
On entry, UPLO specifies whether the upper or lower
triangular part of the band matrix A is being supplied as
follows:
UPLO = 'U' or 'u' The upper triangular part of A is
being supplied.
UPLO = 'L' or 'l' The lower triangular part of A is
being supplied.
Unchanged on exit.
N - INTEGER
On entry, N specifies the order of the matrix A.
N must be at least zero.
Unchanged on exit.
K - INTEGER
On entry, K specifies the number of super-diagonals of the
matrix A. K must satisfy 0 .le. K.
Unchanged on exit.
ALPHA - COMPLEX*16
On entry, ALPHA specifies the scalar alpha.
Unchanged on exit.
A - COMPLEX*16 array, dimension( LDA, N )
Before entry with UPLO = 'U' or 'u', the leading ( k + 1 )
by n part of the array A must contain the upper triangular
band part of the symmetric matrix, supplied column by
column, with the leading diagonal of the matrix in row
( k + 1 ) of the array, the first super-diagonal starting at
position 2 in row k, and so on. The top left k by k triangle
of the array A is not referenced.
The following program segment will transfer the upper
triangular part of a symmetric band matrix from conventional
full matrix storage to band storage:
DO 20, J = 1, N
M = K + 1 - J
DO 10, I = MAX( 1, J - K ), J
A( M + I, J ) = matrix( I, J )
10 CONTINUE
20 CONTINUE
Before entry with UPLO = 'L' or 'l', the leading ( k + 1 )
by n part of the array A must contain the lower triangular
band part of the symmetric matrix, supplied column by
column, with the leading diagonal of the matrix in row 1 of
the array, the first sub-diagonal starting at position 1 in
row 2, and so on. The bottom right k by k triangle of the
array A is not referenced.
The following program segment will transfer the lower
triangular part of a symmetric band matrix from conventional
full matrix storage to band storage:
DO 20, J = 1, N
M = 1 - J
DO 10, I = J, MIN( N, J + K )
A( M + I, J ) = matrix( I, J )
10 CONTINUE
20 CONTINUE
Unchanged on exit.
LDA - INTEGER
On entry, LDA specifies the first dimension of A as declared
in the calling (sub) program. LDA must be at least
( k + 1 ).
Unchanged on exit.
X - COMPLEX*16 array, dimension at least
( 1 + ( N - 1 )*abs( INCX ) ).
Before entry, the incremented array X must contain the
vector x.
Unchanged on exit.
INCX - INTEGER
On entry, INCX specifies the increment for the elements of
X. INCX must not be zero.
Unchanged on exit.
BETA - COMPLEX*16
On entry, BETA specifies the scalar beta.
Unchanged on exit.
Y - COMPLEX*16 array, dimension at least
( 1 + ( N - 1 )*abs( INCY ) ).
Before entry, the incremented array Y must contain the
vector y. On exit, Y is overwritten by the updated vector y.
INCY - INTEGER
On entry, INCY specifies the increment for the elements of
Y. INCY must not be zero.
Unchanged on exit.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zspt01 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16,
dimension( * ) AFAC, integer, dimension( * ) IPIV, complex*16, dimension( ldc, * ) C,
integer LDC, double precision, dimension( * ) RWORK, double precision RESID)
ZSPT01
Purpose:
ZSPT01 reconstructs a symmetric indefinite packed matrix A from its
diagonal pivoting factorization A = U*D*U' or A = L*D*L' and computes
the residual
norm( C - A ) / ( N * norm(A) * EPS ),
where C is the reconstructed matrix and EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
Hermitian matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (N*(N+1)/2)
The original symmetric matrix A, stored as a packed
triangular matrix.
AFAC
AFAC is COMPLEX*16 array, dimension (N*(N+1)/2)
The factored form of the matrix A, stored as a packed
triangular matrix. AFAC contains the block diagonal matrix D
and the multipliers used to obtain the factor L or U from the
L*D*L' or U*D*U' factorization as computed by ZSPTRF.
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices from ZSPTRF.
C
C is COMPLEX*16 array, dimension (LDC,N)
LDC
LDC is INTEGER
The leading dimension of the array C. LDC >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zspt02 (character UPLO, integer N, integer NRHS, complex*16, dimension( * ) A,
complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer
LDB, double precision, dimension( * ) RWORK, double precision RESID)
ZSPT02
Purpose:
ZSPT02 computes the residual in the solution of a complex symmetric
system of linear equations A*x = b when packed storage is used for
the coefficient matrix. The ratio computed is
RESID = norm( B - A*X ) / ( norm(A) * norm(X) * EPS).
where EPS is the machine precision.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
complex symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B, the matrix of right hand sides.
NRHS >= 0.
A
A is COMPLEX*16 array, dimension (N*(N+1)/2)
The original complex symmetric matrix A, stored as a packed
triangular matrix.
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side vectors for the system of
linear equations.
On exit, B is overwritten with the difference B - A*X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zspt03 (character UPLO, integer N, complex*16, dimension( * ) A, complex*16,
dimension( * ) AINV, complex*16, dimension( ldw, * ) WORK, integer LDW, double precision,
dimension( * ) RWORK, double precision RCOND, double precision RESID)
ZSPT03
Purpose:
ZSPT03 computes the residual for a complex symmetric packed matrix
times its inverse:
norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ),
where EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
complex symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (N*(N+1)/2)
The original complex symmetric matrix A, stored as a packed
triangular matrix.
AINV
AINV is COMPLEX*16 array, dimension (N*(N+1)/2)
The (symmetric) inverse of the matrix A, stored as a packed
triangular matrix.
WORK
WORK is COMPLEX*16 array, dimension (LDW,N)
LDW
LDW is INTEGER
The leading dimension of the array WORK. LDW >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RCOND
RCOND is DOUBLE PRECISION
The reciprocal of the condition number of A, computed as
( 1/norm(A) ) / norm(AINV).
RESID
RESID is DOUBLE PRECISION
norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zsyt01 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA,
complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * ) IPIV,
complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * ) RWORK,
double precision RESID)
ZSYT01
Purpose:
ZSYT01 reconstructs a complex symmetric indefinite matrix A from its
block L*D*L' or U*D*U' factorization and computes the residual
norm( C - A ) / ( N * norm(A) * EPS ),
where C is the reconstructed matrix, EPS is the machine epsilon,
L' is the transpose of L, and U' is the transpose of U.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
complex symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original complex symmetric matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
AFAC
AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
The factored form of the matrix A. AFAC contains the block
diagonal matrix D and the multipliers used to obtain the
factor L or U from the block L*D*L' or U*D*U' factorization
as computed by ZSYTRF.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC. LDAFAC >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices from ZSYTRF.
C
C is COMPLEX*16 array, dimension (LDC,N)
LDC
LDC is INTEGER
The leading dimension of the array C. LDC >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zsyt01_rook (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer
LDA, complex*16, dimension( ldafac, * ) AFAC, integer LDAFAC, integer, dimension( * )
IPIV, complex*16, dimension( ldc, * ) C, integer LDC, double precision, dimension( * )
RWORK, double precision RESID)
ZSYT01_ROOK
Purpose:
ZSYT01_ROOK reconstructs a complex symmetric indefinite matrix A from its
block L*D*L' or U*D*U' factorization and computes the residual
norm( C - A ) / ( N * norm(A) * EPS ),
where C is the reconstructed matrix, EPS is the machine epsilon,
L' is the transpose of L, and U' is the transpose of U.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
complex symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original complex symmetric matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
AFAC
AFAC is COMPLEX*16 array, dimension (LDAFAC,N)
The factored form of the matrix A. AFAC contains the block
diagonal matrix D and the multipliers used to obtain the
factor L or U from the block L*D*L' or U*D*U' factorization
as computed by ZSYTRF_ROOK.
LDAFAC
LDAFAC is INTEGER
The leading dimension of the array AFAC. LDAFAC >= max(1,N).
IPIV
IPIV is INTEGER array, dimension (N)
The pivot indices from ZSYTRF_ROOK.
C
C is COMPLEX*16 array, dimension (LDC,N)
LDC
LDC is INTEGER
The leading dimension of the array C. LDC >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2013
subroutine zsyt02 (character UPLO, integer N, integer NRHS, complex*16, dimension( lda, * ) A,
integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, *
) B, integer LDB, double precision, dimension( * ) RWORK, double precision RESID)
ZSYT02
Purpose:
ZSYT02 computes the residual for a solution to a complex symmetric
system of linear equations A*x = b:
RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
where EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of B, the matrix of right hand sides.
NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original complex symmetric matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
On entry, the right hand side vectors for the system of
linear equations.
On exit, B is overwritten with the difference B - A*X.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(B - A*X) / ( norm(A) * norm(X) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine zsyt03 (character UPLO, integer N, complex*16, dimension( lda, * ) A, integer LDA,
complex*16, dimension( ldainv, * ) AINV, integer LDAINV, complex*16, dimension( ldwork, *
) WORK, integer LDWORK, double precision, dimension( * ) RWORK, double precision RCOND,
double precision RESID)
ZSYT03
Purpose:
ZSYT03 computes the residual for a complex symmetric matrix times
its inverse:
norm( I - A*AINV ) / ( N * norm(A) * norm(AINV) * EPS )
where EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the upper or lower triangular part of the
complex symmetric matrix A is stored:
= 'U': Upper triangular
= 'L': Lower triangular
N
N is INTEGER
The number of rows and columns of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The original complex symmetric matrix A.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N)
AINV
AINV is COMPLEX*16 array, dimension (LDAINV,N)
On entry, the inverse of the matrix A, stored as a symmetric
matrix in the same format as A.
In this version, AINV is expanded into a full matrix and
multiplied by A, so the opposing triangle of AINV will be
changed; i.e., if the upper triangular part of AINV is
stored, the lower triangular part will be used as work space.
LDAINV
LDAINV is INTEGER
The leading dimension of the array AINV. LDAINV >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (LDWORK,N)
LDWORK
LDWORK is INTEGER
The leading dimension of the array WORK. LDWORK >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RCOND
RCOND is DOUBLE PRECISION
The reciprocal of the condition number of A, computed as
RCOND = 1/ (norm(A) * norm(AINV)).
RESID
RESID is DOUBLE PRECISION
norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztbt02 (character UPLO, character TRANS, character DIAG, integer N, integer KD,
integer NRHS, complex*16, dimension( ldab, * ) AB, integer LDAB, complex*16, dimension(
ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16,
dimension( * ) WORK, double precision, dimension( * ) RWORK, double precision RESID)
ZTBT02
Purpose:
ZTBT02 computes the residual for the computed solution to a
triangular system of linear equations A*x = b, A**T *x = b, or
A**H *x = b when A is a triangular band matrix. Here A**T denotes
the transpose of A, A**H denotes the conjugate transpose of A, and
x and b are N by NRHS matrices. The test ratio is the maximum over
the number of right hand sides of
norm(b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation applied to A.
= 'N': A *x = b (No transpose)
= 'T': A**T *x = b (Transpose)
= 'C': A**H *x = b (Conjugate transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
KD
KD is INTEGER
The number of superdiagonals or subdiagonals of the
triangular band matrix A. KD >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B. NRHS >= 0.
AB
AB is COMPLEX*16 array, dimension (LDA,N)
The upper or lower triangular band matrix A, stored in the
first kd+1 rows of the array. The j-th column of A is stored
in the j-th column of the array AB as follows:
if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= max(1,KD+1).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (N)
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(op(A)*x - b) / ( norm(op(A)) * norm(x) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztbt03 (character UPLO, character TRANS, character DIAG, integer N, integer KD,
integer NRHS, complex*16, dimension( ldab, * ) AB, integer LDAB, double precision SCALE,
double precision, dimension( * ) CNORM, double precision TSCAL, complex*16, dimension(
ldx, * ) X, integer LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16,
dimension( * ) WORK, double precision RESID)
ZTBT03
Purpose:
ZTBT03 computes the residual for the solution to a scaled triangular
system of equations A*x = s*b, A**T *x = s*b, or A**H *x = s*b
when A is a triangular band matrix. Here A**T denotes the transpose
of A, A**H denotes the conjugate transpose of A, s is a scalar, and
x and b are N by NRHS matrices. The test ratio is the maximum over
the number of right hand sides of
norm(s*b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation applied to A.
= 'N': A *x = s*b (No transpose)
= 'T': A**T *x = s*b (Transpose)
= 'C': A**H *x = s*b (Conjugate transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
KD
KD is INTEGER
The number of superdiagonals or subdiagonals of the
triangular band matrix A. KD >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B. NRHS >= 0.
AB
AB is COMPLEX*16 array, dimension (LDAB,N)
The upper or lower triangular band matrix A, stored in the
first kd+1 rows of the array. The j-th column of A is stored
in the j-th column of the array AB as follows:
if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= KD+1.
SCALE
SCALE is DOUBLE PRECISION
The scaling factor s used in solving the triangular system.
CNORM
CNORM is DOUBLE PRECISION array, dimension (N)
The 1-norms of the columns of A, not counting the diagonal.
TSCAL
TSCAL is DOUBLE PRECISION
The scaling factor used in computing the 1-norms in CNORM.
CNORM actually contains the column norms of TSCAL*A.
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (N)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(op(A)*x - s*b) / ( norm(op(A)) * norm(x) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztbt05 (character UPLO, character TRANS, character DIAG, integer N, integer KD,
integer NRHS, complex*16, dimension( ldab, * ) AB, integer LDAB, complex*16, dimension(
ldb, * ) B, integer LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
dimension( ldxact, * ) XACT, integer LDXACT, double precision, dimension( * ) FERR, double
precision, dimension( * ) BERR, double precision, dimension( * ) RESLTS)
ZTBT05
Purpose:
ZTBT05 tests the error bounds from iterative refinement for the
computed solution to a system of equations A*X = B, where A is a
triangular band matrix.
RESLTS(1) = test of the error bound
= norm(X - XACT) / ( norm(X) * FERR )
A large value is returned if this ratio is not less than one.
RESLTS(2) = residual from the iterative refinement routine
= the maximum of BERR / ( NZ*EPS + (*) ), where
(*) = NZ*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
and NZ = max. number of nonzeros in any row of A, plus 1
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations.
= 'N': A * X = B (No transpose)
= 'T': A'* X = B (Transpose)
= 'C': A'* X = B (Conjugate transpose = Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
KD
KD is INTEGER
The number of super-diagonals of the matrix A if UPLO = 'U',
or the number of sub-diagonals if UPLO = 'L'. KD >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
AB
AB is COMPLEX*16 array, dimension (LDAB,N)
The upper or lower triangular band matrix A, stored in the
first kd+1 rows of the array. The j-th column of A is stored
in the j-th column of the array AB as follows:
if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
If DIAG = 'U', the diagonal elements of A are not referenced
and are assumed to be 1.
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= KD+1.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is COMPLEX*16 array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is DOUBLE PRECISION array, dimension (NRHS)
The estimated forward error bounds for each solution vector
X. If XTRUE is the true solution, FERR bounds the magnitude
of the largest entry in (X - XTRUE) divided by the magnitude
of the largest entry in X.
BERR
BERR is DOUBLE PRECISION array, dimension (NRHS)
The componentwise relative backward error of each solution
vector (i.e., the smallest relative change in any entry of A
or B that makes X an exact solution).
RESLTS
RESLTS is DOUBLE PRECISION array, dimension (2)
The maximum over the NRHS solution vectors of the ratios:
RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
RESLTS(2) = BERR / ( NZ*EPS + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztbt06 (double precision RCOND, double precision RCONDC, character UPLO, character
DIAG, integer N, integer KD, complex*16, dimension( ldab, * ) AB, integer LDAB, double
precision, dimension( * ) RWORK, double precision RAT)
ZTBT06
Purpose:
ZTBT06 computes a test ratio comparing RCOND (the reciprocal
condition number of a triangular matrix A) and RCONDC, the estimate
computed by ZTBCON. Information about the triangular matrix A is
used if one estimate is zero and the other is non-zero to decide if
underflow in the estimate is justified.
Parameters:
RCOND
RCOND is DOUBLE PRECISION
The estimate of the reciprocal condition number obtained by
forming the explicit inverse of the matrix A and computing
RCOND = 1/( norm(A) * norm(inv(A)) ).
RCONDC
RCONDC is DOUBLE PRECISION
The estimate of the reciprocal condition number computed by
ZTBCON.
UPLO
UPLO is CHARACTER
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
DIAG
DIAG is CHARACTER
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
KD
KD is INTEGER
The number of superdiagonals or subdiagonals of the
triangular band matrix A. KD >= 0.
AB
AB is COMPLEX*16 array, dimension (LDAB,N)
The upper or lower triangular band matrix A, stored in the
first kd+1 rows of the array. The j-th column of A is stored
in the j-th column of the array AB as follows:
if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;
if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).
LDAB
LDAB is INTEGER
The leading dimension of the array AB. LDAB >= KD+1.
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RAT
RAT is DOUBLE PRECISION
The test ratio. If both RCOND and RCONDC are nonzero,
RAT = MAX( RCOND, RCONDC )/MIN( RCOND, RCONDC ) - 1.
If RAT = 0, the two estimates are exactly the same.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztpt01 (character UPLO, character DIAG, integer N, complex*16, dimension( * ) AP,
complex*16, dimension( * ) AINVP, double precision RCOND, double precision, dimension( * )
RWORK, double precision RESID)
ZTPT01
Purpose:
ZTPT01 computes the residual for a triangular matrix A times its
inverse when A is stored in packed format:
RESID = norm(A*AINV - I) / ( N * norm(A) * norm(AINV) * EPS ),
where EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
AP
AP is COMPLEX*16 array, dimension (N*(N+1)/2)
The original upper or lower triangular matrix A, packed
columnwise in a linear array. The j-th column of A is stored
in the array AP as follows:
if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
if UPLO = 'L',
AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.
AINVP
AINVP is COMPLEX*16 array, dimension (N*(N+1)/2)
On entry, the (triangular) inverse of the matrix A, packed
columnwise in a linear array as in AP.
On exit, the contents of AINVP are destroyed.
RCOND
RCOND is DOUBLE PRECISION
The reciprocal condition number of A, computed as
1/(norm(A) * norm(AINV)).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
norm(A*AINV - I) / ( N * norm(A) * norm(AINV) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztpt02 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
complex*16, dimension( * ) AP, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK, double precision,
dimension( * ) RWORK, double precision RESID)
ZTPT02
Purpose:
ZTPT02 computes the residual for the computed solution to a
triangular system of linear equations A*x = b, A**T *x = b, or
A**H *x = b, when the triangular matrix A is stored in packed format.
Here A**T denotes the transpose of A, A**H denotes the conjugate
transpose of A, and x and b are N by NRHS matrices. The test ratio
is the maximum over the number of right hand sides of
the maximum over the number of right hand sides of
norm(b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation applied to A.
= 'N': A *x = b (No transpose)
= 'T': A**T *x = b (Transpose)
= 'C': A**H *x = b (Conjugate transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B. NRHS >= 0.
AP
AP is COMPLEX*16 array, dimension (N*(N+1)/2)
The upper or lower triangular matrix A, packed columnwise in
a linear array. The j-th column of A is stored in the array
AP as follows:
if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
if UPLO = 'L',
AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (N)
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(op(A)*x - b) / ( norm(op(A)) * norm(x) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztpt03 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
complex*16, dimension( * ) AP, double precision SCALE, double precision, dimension( * )
CNORM, double precision TSCAL, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK, double precision
RESID)
ZTPT03
Purpose:
ZTPT03 computes the residual for the solution to a scaled triangular
system of equations A*x = s*b, A**T *x = s*b, or A**H *x = s*b,
when the triangular matrix A is stored in packed format. Here A**T
denotes the transpose of A, A**H denotes the conjugate transpose of
A, s is a scalar, and x and b are N by NRHS matrices. The test ratio
is the maximum over the number of right hand sides of
norm(s*b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation applied to A.
= 'N': A *x = s*b (No transpose)
= 'T': A**T *x = s*b (Transpose)
= 'C': A**H *x = s*b (Conjugate transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B. NRHS >= 0.
AP
AP is COMPLEX*16 array, dimension (N*(N+1)/2)
The upper or lower triangular matrix A, packed columnwise in
a linear array. The j-th column of A is stored in the array
AP as follows:
if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
if UPLO = 'L',
AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.
SCALE
SCALE is DOUBLE PRECISION
The scaling factor s used in solving the triangular system.
CNORM
CNORM is DOUBLE PRECISION array, dimension (N)
The 1-norms of the columns of A, not counting the diagonal.
TSCAL
TSCAL is DOUBLE PRECISION
The scaling factor used in computing the 1-norms in CNORM.
CNORM actually contains the column norms of TSCAL*A.
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (N)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(op(A)*x - s*b) / ( norm(op(A)) * norm(x) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztpt05 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
complex*16, dimension( * ) AP, complex*16, dimension( ldb, * ) B, integer LDB, complex*16,
dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * ) XACT, integer
LDXACT, double precision, dimension( * ) FERR, double precision, dimension( * ) BERR,
double precision, dimension( * ) RESLTS)
ZTPT05
Purpose:
ZTPT05 tests the error bounds from iterative refinement for the
computed solution to a system of equations A*X = B, where A is a
triangular matrix in packed storage format.
RESLTS(1) = test of the error bound
= norm(X - XACT) / ( norm(X) * FERR )
A large value is returned if this ratio is not less than one.
RESLTS(2) = residual from the iterative refinement routine
= the maximum of BERR / ( (n+1)*EPS + (*) ), where
(*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations.
= 'N': A * X = B (No transpose)
= 'T': A'* X = B (Transpose)
= 'C': A'* X = B (Conjugate transpose = Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
AP
AP is COMPLEX*16 array, dimension (N*(N+1)/2)
The upper or lower triangular matrix A, packed columnwise in
a linear array. The j-th column of A is stored in the array
AP as follows:
if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
If DIAG = 'U', the diagonal elements of A are not referenced
and are assumed to be 1.
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is COMPLEX*16 array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is DOUBLE PRECISION array, dimension (NRHS)
The estimated forward error bounds for each solution vector
X. If XTRUE is the true solution, FERR bounds the magnitude
of the largest entry in (X - XTRUE) divided by the magnitude
of the largest entry in X.
BERR
BERR is DOUBLE PRECISION array, dimension (NRHS)
The componentwise relative backward error of each solution
vector (i.e., the smallest relative change in any entry of A
or B that makes X an exact solution).
RESLTS
RESLTS is DOUBLE PRECISION array, dimension (2)
The maximum over the NRHS solution vectors of the ratios:
RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
RESLTS(2) = BERR / ( (n+1)*EPS + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztpt06 (double precision RCOND, double precision RCONDC, character UPLO, character
DIAG, integer N, complex*16, dimension( * ) AP, double precision, dimension( * ) RWORK,
double precision RAT)
ZTPT06
Purpose:
ZTPT06 computes a test ratio comparing RCOND (the reciprocal
condition number of the triangular matrix A) and RCONDC, the estimate
computed by ZTPCON. Information about the triangular matrix is used
if one estimate is zero and the other is non-zero to decide if
underflow in the estimate is justified.
Parameters:
RCOND
RCOND is DOUBLE PRECISION
The estimate of the reciprocal condition number obtained by
forming the explicit inverse of the matrix A and computing
RCOND = 1/( norm(A) * norm(inv(A)) ).
RCONDC
RCONDC is DOUBLE PRECISION
The estimate of the reciprocal condition number computed by
ZTPCON.
UPLO
UPLO is CHARACTER
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
DIAG
DIAG is CHARACTER
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
AP
AP is COMPLEX*16 array, dimension (N*(N+1)/2)
The upper or lower triangular matrix A, packed columnwise in
a linear array. The j-th column of A is stored in the array
AP as follows:
if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j;
if UPLO = 'L',
AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n.
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RAT
RAT is DOUBLE PRECISION
The test ratio. If both RCOND and RCONDC are nonzero,
RAT = MAX( RCOND, RCONDC )/MIN( RCOND, RCONDC ) - 1.
If RAT = 0, the two estimates are exactly the same.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztrt01 (character UPLO, character DIAG, integer N, complex*16, dimension( lda, * )
A, integer LDA, complex*16, dimension( ldainv, * ) AINV, integer LDAINV, double precision
RCOND, double precision, dimension( * ) RWORK, double precision RESID)
ZTRT01
Purpose:
ZTRT01 computes the residual for a triangular matrix A times its
inverse:
RESID = norm( A*AINV - I ) / ( N * norm(A) * norm(AINV) * EPS ),
where EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The triangular matrix A. If UPLO = 'U', the leading n by n
upper triangular part of the array A contains the upper
triangular matrix, and the strictly lower triangular part of
A is not referenced. If UPLO = 'L', the leading n by n lower
triangular part of the array A contains the lower triangular
matrix, and the strictly upper triangular part of A is not
referenced. If DIAG = 'U', the diagonal elements of A are
also not referenced and are assumed to be 1.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
AINV
AINV is COMPLEX*16 array, dimension (LDAINV,N)
On entry, the (triangular) inverse of the matrix A, in the
same storage format as A.
On exit, the contents of AINV are destroyed.
LDAINV
LDAINV is INTEGER
The leading dimension of the array AINV. LDAINV >= max(1,N).
RCOND
RCOND is DOUBLE PRECISION
The reciprocal condition number of A, computed as
1/(norm(A) * norm(AINV)).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
norm(A*AINV - I) / ( N * norm(A) * norm(AINV) * EPS )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztrt02 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer
LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK,
double precision, dimension( * ) RWORK, double precision RESID)
ZTRT02
Purpose:
ZTRT02 computes the residual for the computed solution to a
triangular system of linear equations A*x = b, A**T *x = b,
or A**H *x = b. Here A is a triangular matrix, A**T is the transpose
of A, A**H is the conjugate transpose of A, and x and b are N by NRHS
matrices. The test ratio is the maximum over the number of right
hand sides of
norm(b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation applied to A.
= 'N': A *x = b (No transpose)
= 'T': A**T *x = b (Transpose)
= 'C': A**H *x = b (Conjugate transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The triangular matrix A. If UPLO = 'U', the leading n by n
upper triangular part of the array A contains the upper
triangular matrix, and the strictly lower triangular part of
A is not referenced. If UPLO = 'L', the leading n by n lower
triangular part of the array A contains the lower triangular
matrix, and the strictly upper triangular part of A is not
referenced. If DIAG = 'U', the diagonal elements of A are
also not referenced and are assumed to be 1.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (N)
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(op(A)*x - b) / ( norm(op(A)) * norm(x) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztrt03 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
complex*16, dimension( lda, * ) A, integer LDA, double precision SCALE, double precision,
dimension( * ) CNORM, double precision TSCAL, complex*16, dimension( ldx, * ) X, integer
LDX, complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK,
double precision RESID)
ZTRT03
Purpose:
ZTRT03 computes the residual for the solution to a scaled triangular
system of equations A*x = s*b, A**T *x = s*b, or A**H *x = s*b.
Here A is a triangular matrix, A**T denotes the transpose of A, A**H
denotes the conjugate transpose of A, s is a scalar, and x and b are
N by NRHS matrices. The test ratio is the maximum over the number of
right hand sides of
norm(s*b - op(A)*x) / ( norm(op(A)) * norm(x) * EPS ),
where op(A) denotes A, A**T, or A**H, and EPS is the machine epsilon.
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the operation applied to A.
= 'N': A *x = s*b (No transpose)
= 'T': A**T *x = s*b (Transpose)
= 'C': A**H *x = s*b (Conjugate transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of right hand sides, i.e., the number of columns
of the matrices X and B. NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The triangular matrix A. If UPLO = 'U', the leading n by n
upper triangular part of the array A contains the upper
triangular matrix, and the strictly lower triangular part of
A is not referenced. If UPLO = 'L', the leading n by n lower
triangular part of the array A contains the lower triangular
matrix, and the strictly upper triangular part of A is not
referenced. If DIAG = 'U', the diagonal elements of A are
also not referenced and are assumed to be 1.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
SCALE
SCALE is DOUBLE PRECISION
The scaling factor s used in solving the triangular system.
CNORM
CNORM is DOUBLE PRECISION array, dimension (N)
The 1-norms of the columns of A, not counting the diagonal.
TSCAL
TSCAL is DOUBLE PRECISION
The scaling factor used in computing the 1-norms in CNORM.
CNORM actually contains the column norms of TSCAL*A.
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors for the system of linear
equations.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
WORK
WORK is COMPLEX*16 array, dimension (N)
RESID
RESID is DOUBLE PRECISION
The maximum over the number of right hand sides of
norm(op(A)*x - s*b) / ( norm(op(A)) * norm(x) * EPS ).
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztrt05 (character UPLO, character TRANS, character DIAG, integer N, integer NRHS,
complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B, integer
LDB, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldxact, * )
XACT, integer LDXACT, double precision, dimension( * ) FERR, double precision, dimension(
* ) BERR, double precision, dimension( * ) RESLTS)
ZTRT05
Purpose:
ZTRT05 tests the error bounds from iterative refinement for the
computed solution to a system of equations A*X = B, where A is a
triangular n by n matrix.
RESLTS(1) = test of the error bound
= norm(X - XACT) / ( norm(X) * FERR )
A large value is returned if this ratio is not less than one.
RESLTS(2) = residual from the iterative refinement routine
= the maximum of BERR / ( (n+1)*EPS + (*) ), where
(*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
Parameters:
UPLO
UPLO is CHARACTER*1
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
TRANS
TRANS is CHARACTER*1
Specifies the form of the system of equations.
= 'N': A * X = B (No transpose)
= 'T': A'* X = B (Transpose)
= 'C': A'* X = B (Conjugate transpose = Transpose)
DIAG
DIAG is CHARACTER*1
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The number of rows of the matrices X, B, and XACT, and the
order of the matrix A. N >= 0.
NRHS
NRHS is INTEGER
The number of columns of the matrices X, B, and XACT.
NRHS >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The triangular matrix A. If UPLO = 'U', the leading n by n
upper triangular part of the array A contains the upper
triangular matrix, and the strictly lower triangular part of
A is not referenced. If UPLO = 'L', the leading n by n lower
triangular part of the array A contains the lower triangular
matrix, and the strictly upper triangular part of A is not
referenced. If DIAG = 'U', the diagonal elements of A are
also not referenced and are assumed to be 1.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
B
B is COMPLEX*16 array, dimension (LDB,NRHS)
The right hand side vectors for the system of linear
equations.
LDB
LDB is INTEGER
The leading dimension of the array B. LDB >= max(1,N).
X
X is COMPLEX*16 array, dimension (LDX,NRHS)
The computed solution vectors. Each vector is stored as a
column of the matrix X.
LDX
LDX is INTEGER
The leading dimension of the array X. LDX >= max(1,N).
XACT
XACT is COMPLEX*16 array, dimension (LDX,NRHS)
The exact solution vectors. Each vector is stored as a
column of the matrix XACT.
LDXACT
LDXACT is INTEGER
The leading dimension of the array XACT. LDXACT >= max(1,N).
FERR
FERR is DOUBLE PRECISION array, dimension (NRHS)
The estimated forward error bounds for each solution vector
X. If XTRUE is the true solution, FERR bounds the magnitude
of the largest entry in (X - XTRUE) divided by the magnitude
of the largest entry in X.
BERR
BERR is DOUBLE PRECISION array, dimension (NRHS)
The componentwise relative backward error of each solution
vector (i.e., the smallest relative change in any entry of A
or B that makes X an exact solution).
RESLTS
RESLTS is DOUBLE PRECISION array, dimension (2)
The maximum over the NRHS solution vectors of the ratios:
RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR )
RESLTS(2) = BERR / ( (n+1)*EPS + (*) )
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
subroutine ztrt06 (double precision RCOND, double precision RCONDC, character UPLO, character
DIAG, integer N, complex*16, dimension( lda, * ) A, integer LDA, double precision,
dimension( * ) RWORK, double precision RAT)
ZTRT06
Purpose:
ZTRT06 computes a test ratio comparing RCOND (the reciprocal
condition number of a triangular matrix A) and RCONDC, the estimate
computed by ZTRCON. Information about the triangular matrix A is
used if one estimate is zero and the other is non-zero to decide if
underflow in the estimate is justified.
Parameters:
RCOND
RCOND is DOUBLE PRECISION
The estimate of the reciprocal condition number obtained by
forming the explicit inverse of the matrix A and computing
RCOND = 1/( norm(A) * norm(inv(A)) ).
RCONDC
RCONDC is DOUBLE PRECISION
The estimate of the reciprocal condition number computed by
ZTRCON.
UPLO
UPLO is CHARACTER
Specifies whether the matrix A is upper or lower triangular.
= 'U': Upper triangular
= 'L': Lower triangular
DIAG
DIAG is CHARACTER
Specifies whether or not the matrix A is unit triangular.
= 'N': Non-unit triangular
= 'U': Unit triangular
N
N is INTEGER
The order of the matrix A. N >= 0.
A
A is COMPLEX*16 array, dimension (LDA,N)
The triangular matrix A. If UPLO = 'U', the leading n by n
upper triangular part of the array A contains the upper
triangular matrix, and the strictly lower triangular part of
A is not referenced. If UPLO = 'L', the leading n by n lower
triangular part of the array A contains the lower triangular
matrix, and the strictly upper triangular part of A is not
referenced. If DIAG = 'U', the diagonal elements of A are
also not referenced and are assumed to be 1.
LDA
LDA is INTEGER
The leading dimension of the array A. LDA >= max(1,N).
RWORK
RWORK is DOUBLE PRECISION array, dimension (N)
RAT
RAT is DOUBLE PRECISION
The test ratio. If both RCOND and RCONDC are nonzero,
RAT = MAX( RCOND, RCONDC )/MIN( RCOND, RCONDC ) - 1.
If RAT = 0, the two estimates are exactly the same.
Author:
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date:
November 2011
Author
Generated automatically by Doxygen for LAPACK from the source code.