complex16

Collaboration diagram for complex16:

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

---

Detailed Description

This is the group of complex16 LAPACK TESTING LIN routines.

---

Function/Subroutine 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
 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:

April 2012

Definition at line 109 of file zchkaa.f.

Here is the call graph for this function:

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

Definition at line 74 of file zchkab.f.

Here is the call graph for this function:

subroutine zchkeq	(	double precision	THRESH,
		integer	NOUT
	)

ZCHKEQ

Purpose:

 ZCHKEQ tests ZGEEQU, ZGBEQU, ZPOEQU, ZPPEQU and ZPBEQU

Parameters:

[in]	THRESH	THRESH is DOUBLE PRECISION Threshold for testing routines. Should be between 2 and 10.
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 55 of file zchkeq.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NM	NM is INTEGER The number of values of M contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB contained in the vector NBVAL.
[in]	NBVAL	NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[out]	A	A is COMPLEX*16 array, dimension (LA)
[in]	LA	LA is INTEGER The length of the array A. LA >= (KLMAX+KUMAX+1)*NMAX where KLMAX is the largest entry in the local array KLVAL, KUMAX is the largest entry in the local array KUVAL and NMAX is the largest entry in the input array NVAL.
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (LAFAC)
[in]	LAFAC	LAFAC is INTEGER The length of the array AFAC. LAFAC >= (2*KLMAX+KUMAX+1)*NMAX where KLMAX is the largest entry in the local array KLVAL, KUMAX is the largest entry in the local array KUVAL and NMAX is the largest entry in the input array NVAL.
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX,NMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX))
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 190 of file zchkgb.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NM	NM is INTEGER The number of values of M contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB contained in the vector NBVAL.
[in]	NBVAL	NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(2*NMAX,2*NSMAX+NWORK))
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 185 of file zchkge.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*4)
[out]	AF	AF is COMPLEX*16 array, dimension (NMAX*4)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(NMAX)+2*NSMAX)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 147 of file zchkgt.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB contained in the vector NBVAL.
[in]	NBVAL	NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX))
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 172 of file zchkhe.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(2,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NSMAX)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 163 of file zchkhp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NM	NM is INTEGER The number of values of M contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX).
[in]	NBVAL	NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB.
[in]	NXVAL	NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AF	AF is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AQ	AQ is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AL	AL is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AC	AC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	TAU	TAU is COMPLEX*16 array, dimension (NMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 195 of file zchklq.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB contained in the vector NBVAL.
[in]	NBVAL	NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is DOUBLE PRECISION array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is DOUBLE PRECISION array, dimension (NMAX*NMAX)
[out]	AINV	AINV is DOUBLE PRECISION array, dimension (NMAX*NMAX)
[out]	B	B is DOUBLE PRECISION array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is DOUBLE PRECISION array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is DOUBLE PRECISION array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is DOUBLE PRECISION array, dimension (NMAX*max(3,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX))
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 167 of file zchkpb.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB contained in the vector NBVAL.
[in]	NBVAL	NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NSMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 167 of file zchkpo.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX))
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 158 of file zchkpp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB contained in the vector NBVAL.
[in]	NBVAL	NBVAL is INTEGER array, dimension (NBVAL) The values of the block size NB.
[in]	NRANK	NRANK is INTEGER The number of values of RANK contained in the vector RANKVAL.
[in]	RANKVAL	RANKVAL is INTEGER array, dimension (NBVAL) The values of the block size NB.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	PERM	PERM is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	PIV	PIV is INTEGER array, dimension (NMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*3)
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 153 of file zchkps.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*2)
[out]	D	D is DOUBLE PRECISION array, dimension (NMAX*2)
[out]	E	E is COMPLEX*16 array, dimension (NMAX*2)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX))
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 147 of file zchkpt.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NM	NM is INTEGER The number of values of M contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX).
[in]	NBVAL	NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB.
[in]	NXVAL	NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[out]	A	A is COMPLEX*16 array, dimension (MMAX*NMAX) where MMAX is the maximum value of M in MVAL and NMAX is the maximum value of N in NVAL.
[out]	COPYA	COPYA is COMPLEX*16 array, dimension (MMAX*NMAX)
[out]	S	S is DOUBLE PRECISION array, dimension (min(MMAX,NMAX))
[out]	TAU	TAU is COMPLEX*16 array, dimension (MMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (max(M*max(M,N) + 4*min(M,N) + max(M,N)))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (4*NMAX)
[out]	IWORK	IWORK is INTEGER array, dimension (2*NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 157 of file zchkq3.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NM	NM is INTEGER The number of values of M contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX).
[in]	NBVAL	NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB.
[in]	NXVAL	NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AF	AF is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AQ	AQ is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AL	AL is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AC	AC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	TAU	TAU is COMPLEX*16 array, dimension (NMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 195 of file zchkql.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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

ZCHKQP

Purpose:

 ZCHKQP tests ZGEQPF.

Parameters:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NM	NM is INTEGER The number of values of M contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[out]	A	A is COMPLEX*16 array, dimension (MMAX*NMAX) where MMAX is the maximum value of M in MVAL and NMAX is the maximum value of N in NVAL.
[out]	COPYA	COPYA is COMPLEX*16 array, dimension (MMAX*NMAX)
[out]	S	S is DOUBLE PRECISION array, dimension (min(MMAX,NMAX))
[out]	TAU	TAU is COMPLEX*16 array, dimension (MMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (max(M*max(M,N) + 4*min(M,N) + max(M,N)))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (4*NMAX)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 143 of file zchkqp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NM	NM is INTEGER The number of values of M contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX).
[in]	NBVAL	NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB.
[in]	NXVAL	NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AF	AF is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AQ	AQ is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AR	AR is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AC	AC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	TAU	TAU is COMPLEX*16 array, dimension (NMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 200 of file zchkqr.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NM	NM is INTEGER The number of values of M contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB contained in the vector NBVAL.
[in]	NBVAL	NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB.
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 101 of file zchkqrt.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NM	NM is INTEGER The number of values of M contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB contained in the vector NBVAL.
[in]	NBVAL	NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB.
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 102 of file zchkqrtp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 60 of file zchkrfp.f.

Here is the call graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NM	NM is INTEGER The number of values of M contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX).
[in]	NBVAL	NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB.
[in]	NXVAL	NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AF	AF is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AQ	AQ is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AR	AR is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AC	AC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	TAU	TAU is COMPLEX*16 array, dimension (NMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 200 of file zchkrq.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(2,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NSMAX)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 163 of file zchksp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB contained in the vector NBVAL.
[in]	NBVAL	NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(2,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NSMAX)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

Definition at line 172 of file zchksy.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The leading dimension of the work arrays. NMAX >= the maximum value of N in NVAL.
[out]	AB	AB is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX))
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 149 of file zchktb.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The leading dimension of the work arrays. NMAX >= the maximumm value of N in NVAL.
[out]	AP	AP is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	AINVP	AINVP is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX))
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 150 of file zchktp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB contained in the vector NBVAL.
[in]	NBVAL	NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The leading dimension of the work arrays. NMAX >= the maximum value of N in NVAL.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NSMAX))
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 162 of file zchktr.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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 ZTZRQF and ZTZRZF.

Parameters:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NM	NM is INTEGER The number of values of M contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[out]	A	A is COMPLEX*16 array, dimension (MMAX*NMAX) where MMAX is the maximum value of M in MVAL and NMAX is the maximum value of N in NVAL.
[out]	COPYA	COPYA is COMPLEX*16 array, dimension (MMAX*NMAX)
[out]	S	S is DOUBLE PRECISION array, dimension (min(MMAX,NMAX))
[out]	TAU	TAU is COMPLEX*16 array, dimension (MMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (MMAX*NMAX + 4*NMAX + MMAX)
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (2*NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 137 of file zchktz.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NM	NM is INTEGER The number of values of M contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for M or N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL.
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX*2))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension NMAX
[out]	SWORK	SWORK is COMPLEX array, dimension (NMAX*(NSMAX+NMAX))
[out]	IWORK	IWORK is INTEGER array, dimension NMAX
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 151 of file zdrvab.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NM	NM is INTEGER The number of values of N contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix dimension N.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NSMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NSMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(2*NMAX,2*NSMAX+NWORK))
[out]	SWORK	SWORK is COMPLEX array, dimension (NMAX*(NSMAX+NMAX))
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 144 of file zdrvac.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[out]	A	A is COMPLEX*16 array, dimension (LA)
[in]	LA	LA is INTEGER The length of the array A. LA >= (2*NMAX-1)*NMAX where NMAX is the largest entry in NVAL.
[out]	AFB	AFB is COMPLEX*16 array, dimension (LAFB)
[in]	LAFB	LAFB is INTEGER The length of the array AFB. LAFB >= (3*NMAX-2)*NMAX where NMAX is the largest entry in NVAL.
[out]	ASAV	ASAV is COMPLEX*16 array, dimension (LA)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	BSAV	BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	S	S is DOUBLE PRECISION array, dimension (2*NMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS,NMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NRHS))
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[out]	A	A is COMPLEX*16 array, dimension (LA)
[in]	LA	LA is INTEGER The length of the array A. LA >= (2*NMAX-1)*NMAX where NMAX is the largest entry in NVAL.
[out]	AFB	AFB is COMPLEX*16 array, dimension (LAFB)
[in]	LAFB	LAFB is INTEGER The length of the array AFB. LAFB >= (3*NMAX-2)*NMAX where NMAX is the largest entry in NVAL.
[out]	ASAV	ASAV is COMPLEX*16 array, dimension (LA)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	BSAV	BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	S	S is DOUBLE PRECISION array, dimension (2*NMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS,NMAX))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(NMAX,2*NRHS))
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 171 of file zdrvgb.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	ASAV	ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	BSAV	BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	S	S is DOUBLE PRECISION array, dimension (2*NMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (2*NRHS+NMAX)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	ASAV	ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	BSAV	BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	S	S is DOUBLE PRECISION array, dimension (2*NMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (2*NRHS+NMAX)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

Definition at line 163 of file zdrvge.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand sides, NRHS >= 0.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*4)
[out]	AF	AF is COMPLEX*16 array, dimension (NMAX*4)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
[out]	IWORK	IWORK is INTEGER array, dimension (2*NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 139 of file zdrvgt.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (2*NMAX+2*NRHS)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

Definition at line 153 of file zdrvhe.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 156 of file zdrvhp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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, CGELSX, CGELSS,
 ZGELSY and CGELSD.

Parameters:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. The matrix of type j is generated as follows: j=1: A = U*D*V where U and V are random unitary matrices and D has random entries (> 0.1) taken from a uniform distribution (0,1). A is full rank. j=2: The same of 1, but A is scaled up. j=3: The same of 1, but A is scaled down. j=4: A = U*D*V where U and V are random unitary matrices and D has 3*min(M,N)/4 random entries (> 0.1) taken from a uniform distribution (0,1) and the remaining entries set to 0. A is rank-deficient. j=5: The same of 4, but A is scaled up. j=6: The same of 5, but A is scaled down.
[in]	NM	NM is INTEGER The number of values of M contained in the vector MVAL.
[in]	MVAL	MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N.
[in]	NNB	NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX).
[in]	NBVAL	NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB.
[in]	NXVAL	NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[out]	A	A is COMPLEX*16 array, dimension (MMAX*NMAX) where MMAX is the maximum value of M in MVAL and NMAX is the maximum value of N in NVAL.
[out]	COPYA	COPYA is COMPLEX*16 array, dimension (MMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (MMAX*NSMAX) where MMAX is the maximum value of M in MVAL and NSMAX is the maximum value of NRHS in NSVAL.
[out]	COPYB	COPYB is COMPLEX*16 array, dimension (MMAX*NSMAX)
[out]	C	C is COMPLEX*16 array, dimension (MMAX*NSMAX)
[out]	S	S is DOUBLE PRECISION array, dimension (min(MMAX,NMAX))
[out]	COPYS	COPYS is DOUBLE PRECISION array, dimension (min(MMAX,NMAX))
[out]	WORK	WORK is COMPLEX*16 array, dimension (MMAX*NMAX + 4*NMAX + MMAX).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (5*NMAX-1)
[out]	IWORK	IWORK is INTEGER array, dimension (15*NMAX)
[in]	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

Definition at line 208 of file zdrvls.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	ASAV	ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	BSAV	BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	S	S is DOUBLE PRECISION array, dimension (NMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 158 of file zdrvpb.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	ASAV	ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	BSAV	BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	S	S is DOUBLE PRECISION array, dimension (NMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
[in]	NOUT	NOUT is INTEGER The unit number for output.

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	ASAV	ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	BSAV	BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	S	S is DOUBLE PRECISION array, dimension (NMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 158 of file zdrvpo.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	ASAV	ASAV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	BSAV	BSAV is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	S	S is DOUBLE PRECISION array, dimension (NMAX)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 158 of file zdrvpp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*2)
[out]	D	D is DOUBLE PRECISION array, dimension (NMAX*2)
[out]	E	E is COMPLEX*16 array, dimension (NMAX*2)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(3,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 140 of file zdrvpt.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	NOUT	NOUT is INTEGER The unit number for output.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[out]	A	A is COMPLEX*16 array, dimension (LDA,NMAX)
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX).
[out]	ARF	ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).
[out]	WORK	WORK is DOUBLE PRECISION array, dimension ( NMAX )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 96 of file zdrvrf1.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	NOUT	NOUT is INTEGER The unit number for output.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[out]	A	A is COMPLEX*16 array, dimension (LDA,NMAX)
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX).
[out]	ARF	ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).
[out]	AP	AP is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).
[out]	ASAV	ASAV is COMPLEX*16 array, dimension (LDA,NMAX)

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 90 of file zdrvrf2.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	NOUT	NOUT is INTEGER The unit number for output.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[out]	A	A is COMPLEX*16 array, dimension (LDA,NMAX)
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX).
[out]	ARF	ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).
[out]	B1	B1 is COMPLEX*16 array, dimension (LDA,NMAX)
[out]	B2	B2 is COMPLEX*16 array, dimension (LDA,NMAX)
[out]	D_WORK_ZLANGE	D_WORK_ZLANGE is DOUBLE PRECISION array, dimension (NMAX)
[out]	Z_WORK_ZGEQRF	Z_WORK_ZGEQRF is COMPLEX*16 array, dimension (NMAX)
[out]	TAU	TAU is COMPLEX*16 array, dimension (NMAX)

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 119 of file zdrvrf3.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	NOUT	NOUT is INTEGER The unit number for output.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[out]	C1	C1 is COMPLEX*16 array, dimension (LDC,NMAX)
[out]	C2	C2 is COMPLEX*16 array, dimension (LDC,NMAX)
[in]	LDC	LDC is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX).
[out]	CRF	CRF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2).
[out]	A	A is COMPLEX*16 array, dimension (LDA,NMAX)
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX).
[out]	D_WORK_ZLANGE	D_WORK_ZLANGE is DOUBLE PRECISION array, dimension (NMAX)

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 114 of file zdrvrf4.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	NOUT	NOUT is INTEGER The unit number for output.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NNS	NNS is INTEGER The number of values of NRHS contained in the vector NSVAL.
[in]	NSVAL	NSVAL is INTEGER array, dimension (NNS) The values of the number of right-hand sides NRHS.
[in]	NNT	NNT is INTEGER The number of values of MATRIX TYPE contained in the vector NTVAL.
[in]	NTVAL	NTVAL is INTEGER array, dimension (NNT) The values of matrix type (between 0 and 9 for PO/PP/PF matrices).
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	ASAV	ASAV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*MAXRHS)
[out]	BSAV	BSAV is COMPLEX*16 array, dimension (NMAX*MAXRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*MAXRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*MAXRHS)
[out]	ARF	ARF is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2)
[out]	ARFINV	ARFINV is COMPLEX*16 array, dimension ((NMAX*(NMAX+1))/2)
[out]	Z_WORK_ZLATMS	Z_WORK_ZLATMS is COMPLEX*16 array, dimension ( 3*NMAX )
[out]	Z_WORK_ZPOT02	Z_WORK_ZPOT02 is COMPLEX*16 array, dimension ( NMAX*MAXRHS )
[out]	Z_WORK_ZPOT03	Z_WORK_ZPOT03 is COMPLEX*16 array, dimension ( NMAX*NMAX )
[out]	D_WORK_ZLATMS	D_WORK_ZLATMS is DOUBLE PRECISION array, dimension ( NMAX )
[out]	D_WORK_ZLANHE	D_WORK_ZLANHE is DOUBLE PRECISION array, dimension ( NMAX )
[out]	D_WORK_ZPOT01	D_WORK_ZPOT01 is DOUBLE PRECISION array, dimension ( NMAX )
[out]	D_WORK_ZPOT02	D_WORK_ZPOT02 is DOUBLE PRECISION array, dimension ( NMAX )
[out]	D_WORK_ZPOT03	D_WORK_ZPOT03 is DOUBLE PRECISION array, dimension ( NMAX )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 240 of file zdrvrfp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*(NMAX+1)/2)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 156 of file zdrvsp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (NMAX+2*NRHS)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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:

[in]	DOTYPE	DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used.
[in]	NN	NN is INTEGER The number of values of N contained in the vector NVAL.
[in]	NVAL	NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N.
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors to be generated for each linear system.
[in]	THRESH	THRESH is DOUBLE PRECISION The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0.
[in]	TSTERR	TSTERR is LOGICAL Flag that indicates whether error exits are to be tested.
[in]	NMAX	NMAX is INTEGER The maximum value permitted for N, used in dimensioning the work arrays.
[out]	A	A is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AFAC	AFAC is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	AINV	AINV is COMPLEX*16 array, dimension (NMAX*NMAX)
[out]	B	B is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	X	X is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	XACT	XACT is COMPLEX*16 array, dimension (NMAX*NRHS)
[out]	WORK	WORK is COMPLEX*16 array, dimension (NMAX*max(2,NRHS))
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (2*NMAX+2*NRHS)
[out]	IWORK	IWORK is INTEGER array, dimension (NMAX)
[in]	NOUT	NOUT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

Definition at line 153 of file zdrvsy.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 97 of file zebchvxx.f.

Here is the call graph for this function:

subroutine zerrab

(

integer

NUNIT

)

ZERRAB

Purpose:

 DERRAB tests the error exits for ZCGESV.

Parameters:

[in]

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

Definition at line 48 of file zerrab.f.

Here is the call graph for this function:

Here is the caller graph for this function:

subroutine zerrac

(

integer

NUNIT

)

ZERRAC

Purpose:

 ZERRPX tests the error exits for ZCPOSV.

Parameters:

[in]

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

Definition at line 48 of file zerrac.f.

Here is the call graph for this function:

Here is the caller graph for this function:

subroutine zerrge	(	character*3	PATH,
		integer	NUNIT
	)

ZERRGE

ZERRGEX

Purpose:

 ZERRGE tests the error exits for the COMPLEX*16 routines
 for general matrices.

Parameters:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrge.f.

Here is the call graph for this function:

Here is the caller graph for this function:

subroutine zerrgt	(	character*3	PATH,
		integer	NUNIT
	)

ZERRGT

Purpose:

 ZERRGT tests the error exits for the COMPLEX*16 tridiagonal
 routines.

Parameters:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrgt.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrhe.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrlq.f.

Here is the call graph for this function:

Here is the caller graph for this function:

subroutine zerrls	(	character*3	PATH,
		integer	NUNIT
	)

ZERRLS

Purpose:

 ZERRLS tests the error exits for the COMPLEX*16 least squares
 driver routines (ZGELS, CGELSS, CGELSX, CGELSY, CGELSD).

Parameters:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrls.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrpo.f.

Here is the call graph for this function:

Here is the caller graph for this function:

subroutine zerrps	(	character*3	PATH,
		integer	NUNIT
	)

ZERRPS

Purpose:

 ZERRPS tests the error exits for the COMPLEX routines
 for ZPSTRF.

Parameters:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrps.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrql.f.

Here is the call graph for this function:

Here is the caller graph for this function:

subroutine zerrqp	(	character*3	PATH,
		integer	NUNIT
	)

ZERRQP

Purpose:

 ZERRQP tests the error exits for ZGEQPF and CGEQP3.

Parameters:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 55 of file zerrqp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrqr.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrqrt.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrqrtp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]

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

Definition at line 53 of file zerrrfp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrrq.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrsy.f.

Here is the call graph for this function:

Here is the caller graph for this function:

subroutine zerrtr	(	character*3	PATH,
		integer	NUNIT
	)

ZERRTR

Purpose:

 ZERRTR tests the error exits for the COMPLEX*16 triangular routines.

Parameters:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 55 of file zerrtr.f.

Here is the call graph for this function:

Here is the caller graph for this function:

subroutine zerrtz	(	character*3	PATH,
		integer	NUNIT
	)

ZERRTZ

Purpose:

 ZERRTZ tests the error exits for ZTZRQF and ZTZRZF.

Parameters:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 55 of file zerrtz.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

Purpose:

 ZERRVX tests the error exits for the COMPLEX*16 driver routines
 for solving linear systems of equations.

Parameters:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name for the routines to be tested.
[in]	NUNIT	NUNIT is INTEGER The unit number for output.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 56 of file zerrvx.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= 0.
[in]	KL	KL is INTEGER The number of subdiagonals within the band of A. KL >= 0.
[in]	KU	KU is INTEGER The number of superdiagonals within the band of A. KU >= 0.
[in,out]	A	A is COMPLEX*16 array, dimension (LDA,N) The original matrix A in band storage, stored in rows 1 to KL+KU+1.
[in]	LDA	LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,KL+KU+1).
[in]	AFAC	AFAC is COMPLEX*16 array, dimension (LDAFAC,N) The factored form of the matrix A. AFAC contains the banded factors L and U from the L*U factorization, as computed by ZGBTRF. U is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and the multipliers used during the factorization are stored in rows KL+KU+2 to 2*KL+KU+1. See ZGBTRF for further details.
[in]	LDAFAC	LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,2*KL*KU+1).
[in]	IPIV	IPIV is INTEGER array, dimension (min(M,N)) The pivot indices from ZGBTRF.
[out]	WORK	WORK is COMPLEX*16 array, dimension (2*KL+KU+1)
[out]	RESID	RESID is DOUBLE PRECISION norm(L*U - A) / ( N * norm(A) * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 126 of file zgbt01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	TRANS	TRANS is CHARACTER*1 Specifies the form of the system of equations: = 'N': A *x = b = 'T': A'*x = b, where A' is the transpose of A = 'C': A'*x = b, where A' is the transpose of A
[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= 0.
[in]	KL	KL is INTEGER The number of subdiagonals within the band of A. KL >= 0.
[in]	KU	KU is INTEGER The number of superdiagonals within the band of A. KU >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of B. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original matrix A in band storage, stored in rows 1 to KL+KU+1.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,KL+KU+1).
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. If TRANS = 'N', LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B - A*X.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. IF TRANS = 'N', LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
[out]	RESID	RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 139 of file zgbt02.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	TRANS	TRANS is CHARACTER*1 Specifies the form of the system of equations. = 'N': A * X = B (No transpose) = 'T': A**T * X = B (Transpose) = 'C': A**H * X = B (Conjugate transpose = Transpose)
[in]	N	N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0.
[in]	KL	KL is INTEGER The number of subdiagonals within the band of A. KL >= 0.
[in]	KU	KU is INTEGER The number of superdiagonals within the band of A. KU >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0.
[in]	AB	AB is COMPLEX*16 array, dimension (LDAB,N) The original band matrix A, stored in rows 1 to KL+KU+1. The 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).
[in]	LDAB	LDAB is INTEGER The leading dimension of the array AB. LDAB >= KL+KU+1.
[in]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[in]	XACT	XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT.
[in]	LDXACT	LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N).
[in]	FERR	FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X - XTRUE) divided by the magnitude of the largest entry in X.
[in]	BERR	BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution).
[out]	RESLTS	RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 176 of file zgbt05.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= M >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of B. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) Details of the LQ factorization of the original matrix A as returned by ZGELQF.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= M.
[in]	TAU	TAU is COMPLEX*16 array, dimension (M) Details of the orthogonal matrix Q.
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the m-by-nrhs right hand side matrix B. On exit, the n-by-nrhs solution matrix X.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= N.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The length of the array WORK. LWORK must be at least NRHS, and should be at least NRHS*NB, where NB is the block size for this environment.
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 121 of file zgelqs.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows in A.
[in]	N	N is INTEGER The number of columns in A.
[in]	A	A is COMPLEX*16 array, dimension (LDA, N) The matrix.
[in]	LDA	LDA is INTEGER Leading dimension of A.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 69 of file zgennd.f.

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. M >= N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of B. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) Details of the QL factorization of the original matrix A as returned by ZGEQLF.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= M.
[in]	TAU	TAU is COMPLEX*16 array, dimension (N) Details of the orthogonal matrix Q.
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the m-by-nrhs right hand side matrix B. On exit, the n-by-nrhs solution matrix X, stored in rows m-n+1:m.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= M.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The length of the array WORK. LWORK must be at least NRHS, and should be at least NRHS*NB, where NB is the block size for this environment.
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 122 of file zgeqls.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. M >= N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of B. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) Details of the QR factorization of the original matrix A as returned by ZGEQRF.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= M.
[in]	TAU	TAU is COMPLEX*16 array, dimension (N) Details of the orthogonal matrix Q.
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the m-by-nrhs right hand side matrix B. On exit, the n-by-nrhs solution matrix X.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= M.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The length of the array WORK. LWORK must be at least NRHS, and should be at least NRHS*NB, where NB is the block size for this environment.
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 121 of file zgeqrs.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= M >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of B. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) Details of the RQ factorization of the original matrix A as returned by ZGERQF.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= M.
[in]	TAU	TAU is COMPLEX*16 array, dimension (M) Details of the orthogonal matrix Q.
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the right hand side vectors for the linear system. On exit, the solution vectors X. Each solution vector is contained in rows 1:N of a column of B.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The length of the array WORK. LWORK must be at least NRHS, and should be at least NRHS*NB, where NB is the block size for this environment.
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 122 of file zgerqs.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original M x N matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).
[in,out]	AFAC	AFAC is COMPLEX*16 array, dimension (LDAFAC,N) The factored form of the matrix A. AFAC contains the factors L and U from the L*U factorization as computed by ZGETRF. Overwritten with the reconstructed matrix, and then with the difference L*U - A.
[in]	LDAFAC	LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,M).
[in]	IPIV	IPIV is INTEGER array, dimension (N) The pivot indices from ZGETRF.
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (M)
[out]	RESID	RESID is DOUBLE PRECISION norm(L*U - A) / ( N * norm(A) * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 108 of file zget01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	TRANS	TRANS is CHARACTER*1 Specifies the form of the system of equations: = 'N': A *x = b = 'T': A^T*x = b, where A^T is the transpose of A = 'C': A^H*x = b, where A^H is the conjugate transpose of A
[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original M x N matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. If TRANS = 'N', LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B - A*X.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. IF TRANS = 'N', LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (M)
[out]	RESID	RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 133 of file zget02.f.

Here is the call graph for this function:

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:

[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original N x N matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).
[in]	AINV	AINV is COMPLEX*16 array, dimension (LDAINV,N) The inverse of the matrix A.
[in]	LDAINV	LDAINV is INTEGER The leading dimension of the array AINV. LDAINV >= max(1,N).
[out]	WORK	WORK is COMPLEX*16 array, dimension (LDWORK,N)
[in]	LDWORK	LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RCOND	RCOND is DOUBLE PRECISION The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV).
[out]	RESID	RESID is DOUBLE PRECISION norm(I - AINV*A) / ( N * norm(A) * norm(AINV) * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 110 of file zget03.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	N	N is INTEGER The number of rows of the matrices X and XACT. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of the matrices X and XACT. NRHS >= 0.
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[in]	XACT	XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT.
[in]	LDXACT	LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N).
[in]	RCOND	RCOND is DOUBLE PRECISION The reciprocal of the condition number of the coefficient matrix in the system of equations.
[out]	RESID	RESID is DOUBLE PRECISION The maximum over the NRHS solution vectors of ( norm(X-XACT) * RCOND ) / ( norm(XACT) * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 103 of file zget04.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	TRANS	TRANS is CHARACTER*1 Specifies the form of the system of equations. = 'N': A * X = B (No transpose) = 'T': A**T * X = B (Transpose) = 'C': A**H * X = B (Conjugate transpose = Transpose)
[in]	N	N is INTEGER The number of rows of the matrices X and XACT. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of the matrices X and XACT. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original n by n matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).
[in]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[in]	XACT	XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT.
[in]	LDXACT	LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N).
[in]	FERR	FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X - XTRUE) divided by the magnitude of the largest entry in X.
[in]	CHKFERR	CHKFERR is LOGICAL Set to .TRUE. to check FERR, .FALSE. not to check FERR. When the test system is ill-conditioned, the "true" solution in XACT may be incorrect.
[in]	BERR	BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution).
[out]	RESLTS	RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( (n+1)*EPS + (*) )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 166 of file zget07.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	TRANS	TRANS is CHARACTER*1 Specifies the form of the system of equations: = 'N': A *x = b = 'T': A^T*x = b, where A^T is the transpose of A = 'C': A^H*x = b, where A^H is the conjugate transpose of A
[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original M x N matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. If TRANS = 'N', LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B - A*X.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. IF TRANS = 'N', LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (M)
[out]	RESID	RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 133 of file zget08.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	N	N is INTEGTER The order of the matrix A. N >= 0.
[in]	DL	DL is COMPLEX*16 array, dimension (N-1) The (n-1) sub-diagonal elements of A.
[in]	D	D is COMPLEX*16 array, dimension (N) The diagonal elements of A.
[in]	DU	DU is COMPLEX*16 array, dimension (N-1) The (n-1) super-diagonal elements of A.
[in]	DLF	DLF is COMPLEX*16 array, dimension (N-1) The (n-1) multipliers that define the matrix L from the LU factorization of A.
[in]	DF	DF is COMPLEX*16 array, dimension (N) The n diagonal elements of the upper triangular matrix U from the LU factorization of A.
[in]	DUF	DUF is COMPLEX*16 array, dimension (N-1) The (n-1) elements of the first super-diagonal of U.
[in]	DU2	DU2 is COMPLEX*16 array, dimension (N-2) The (n-2) elements of the second super-diagonal of U.
[in]	IPIV	IPIV is INTEGER array, dimension (N) The pivot indices; for 1 <= i <= n, row i of the matrix was interchanged with row IPIV(i). IPIV(i) will always be either i or i+1; IPIV(i) = i indicates a row interchange was not required.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LDWORK,N)
[in]	LDWORK	LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RESID	RESID is DOUBLE PRECISION The scaled residual: norm(L*U - A) / (norm(A) * EPS)

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 134 of file zgtt01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	TRANS	TRANS is CHARACTER Specifies the form of the residual. = 'N': B - A * X (No transpose) = 'T': B - A**T * X (Transpose) = 'C': B - A**H * X (Conjugate transpose)
[in]	N	N is INTEGTER The order of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0.
[in]	DL	DL is COMPLEX*16 array, dimension (N-1) The (n-1) sub-diagonal elements of A.
[in]	D	D is COMPLEX*16 array, dimension (N) The diagonal elements of A.
[in]	DU	DU is COMPLEX*16 array, dimension (N-1) The (n-1) super-diagonal elements of A.
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B - op(A)*X.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]	RESID	RESID is DOUBLE PRECISION norm(B - op(A)*X) / (norm(A) * norm(X) * EPS)

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 124 of file zgtt02.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	TRANS	TRANS is CHARACTER*1 Specifies the form of the system of equations. = 'N': A * X = B (No transpose) = 'T': A**T * X = B (Transpose) = 'C': A**H * X = B (Conjugate transpose = Transpose)
[in]	N	N is INTEGER The number of rows of the matrices X and XACT. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of the matrices X and XACT. NRHS >= 0.
[in]	DL	DL is COMPLEX*16 array, dimension (N-1) The (n-1) sub-diagonal elements of A.
[in]	D	D is COMPLEX*16 array, dimension (N) The diagonal elements of A.
[in]	DU	DU is COMPLEX*16 array, dimension (N-1) The (n-1) super-diagonal elements of A.
[in]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[in]	XACT	XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT.
[in]	LDXACT	LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N).
[in]	FERR	FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X - XTRUE) divided by the magnitude of the largest entry in X.
[in]	BERR	BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution).
[out]	RESLTS	RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 165 of file zgtt05.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original Hermitian matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N)
[in]	AFAC	AFAC is COMPLEX*16 array, dimension (LDAFAC,N) The factored form of the matrix A. AFAC contains the block diagonal matrix D and the multipliers used to obtain the factor L or U from the block L*D*L' or U*D*U' factorization as computed by ZHETRF.
[in]	LDAFAC	LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,N).
[in]	IPIV	IPIV is INTEGER array, dimension (N) The pivot indices from ZHETRF.
[out]	C	C is COMPLEX*16 array, dimension (LDC,N)
[in]	LDC	LDC is INTEGER The leading dimension of the array C. LDC >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RESID	RESID is DOUBLE PRECISION If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 126 of file zhet01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	A	A is COMPLEX*16 array, dimension (N*(N+1)/2) The original Hermitian matrix A, stored as a packed triangular matrix.
[in]	AFAC	AFAC is COMPLEX*16 array, dimension (N*(N+1)/2) The factored form of the matrix A, stored as a packed triangular matrix. AFAC contains the block diagonal matrix D and the multipliers used to obtain the factor L or U from the block L*D*L' or U*D*U' factorization as computed by ZHPTRF.
[in]	IPIV	IPIV is INTEGER array, dimension (N) The pivot indices from ZHPTRF.
[out]	C	C is COMPLEX*16 array, dimension (LDC,N)
[in]	LDC	LDC is INTEGER The leading dimension of the array C. LDC >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RESID	RESID is DOUBLE PRECISION If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 114 of file zhpt01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	N	N is INTEGER The dimension of the matrix A.
[in]	NRHS	NRHS is NRHS The requested number of right-hand sides.
[out]	A	A is COMPLEX array, dimension (LDA, N) The generated scaled Hilbert matrix.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= N.
[out]	X	X is COMPLEX array, dimension (LDX, NRHS) The generated exact solutions. Currently, the first NRHS columns of the inverse Hilbert matrix.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= N.
[out]	B	B is REAL array, dimension (LDB, NRHS) The generated right-hand sides. Currently, the first NRHS columns of LCM(1, 2, ..., 2*N-1) * the identity matrix.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= N.
[out]	WORK	WORK is REAL array, dimension (N)
[out]	INFO	INFO is INTEGER = 0: successful exit = 1: N is too large; the data is still generated but may not be not exact. < 0: if INFO = -i, the i-th argument had an illegal value
[in]	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

Definition at line 134 of file zlahilb.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	N	N is INTEGER The number of diagonal elements of A.
[in,out]	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.
[in]	INDA	INDA is INTEGER The increment between A(1) and the next diagonal element of A. Typical values are = LDA+1: square matrices with leading dimension LDA = 2: packed upper triangular matrix, starting at A(1,1) = N: packed lower triangular matrix, starting at A(1,1)
[in]	VINDA	VINDA is INTEGER The change in the diagonal increment between columns of A. Typical values are = 0: no change, the row and column increments in A are fixed = 1: packed upper triangular matrix = -1: packed lower triangular matrix

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 84 of file zlaipd.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER Specifies whether the superdiagonal or the subdiagonal of the tridiagonal matrix A is stored. = 'U': Upper, E is the superdiagonal of A. = 'L': Lower, E is the subdiagonal of A.
[in]	N	N is INTEGER The order of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices X and B.
[in]	ALPHA	ALPHA is DOUBLE PRECISION The scalar alpha. ALPHA must be 1. or -1.; otherwise, it is assumed to be 0.
[in]	D	D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix A.
[in]	E	E is COMPLEX*16 array, dimension (N-1) The (n-1) subdiagonal or superdiagonal elements of A.
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The N by NRHS matrix X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(N,1).
[in]	BETA	BETA is DOUBLE PRECISION The scalar beta. BETA must be 0., 1., or -1.; otherwise, it is assumed to be 1.
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the N by NRHS matrix B. On exit, B is overwritten by the matrix expression B := alpha * A * X + beta * B.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(N,1).

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 129 of file zlaptm.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	PATH	PATH is CHARACTER*3 The type of the complex matrix A. PATH may be given in any combination of upper and lower case. Valid paths include xGE: General m x n matrix xGB: General banded matrix xPO: Hermitian positive definite, 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.
[in]	XTYPE	XTYPE is CHARACTER*1 Specifies how the exact solution X will be determined: = 'N': New solution; generate a random X. = 'C': Computed; use value of X on entry.
[in]	UPLO	UPLO is CHARACTER*1 Used only if A is symmetric or triangular; specifies whether the upper or lower triangular part of the matrix A is stored. = 'U': Upper triangular = 'L': Lower triangular
[in]	TRANS	TRANS is CHARACTER*1 Used only if A is nonsymmetric; specifies the operation applied to the matrix A. = 'N': B := A * X = 'T': B := A**T * X = 'C': B := A**H * X
[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= 0.
[in]	KL	KL is INTEGER Used only if A is a band matrix; specifies the number of subdiagonals of A if A is a general band matrix or if A is symmetric or triangular and UPLO = 'L'; specifies the number of superdiagonals of A if A is symmetric or triangular and UPLO = 'U'. 0 <= KL <= M-1.
[in]	KU	KU is INTEGER Used only if A is a general band matrix or if A is triangular. If PATH = xGB, specifies the number of superdiagonals of A, and 0 <= KU <= 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
[in]	NRHS	NRHS is INTEGER The number of right hand side vectors in the system A*X = B.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The test matrix whose type is given by PATH.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. If PATH = xGB, LDA >= KL+KU+1. If PATH = xPB, xSB, xHB, or xTB, LDA >= KL+1. Otherwise, LDA >= max(1,M).
[in,out]	X	X is or output) COMPLEX*16 array, dimension (LDX,NRHS) On entry, if XTYPE = 'C' (for 'Computed'), then X contains the exact solution to the system of linear equations. On exit, if XTYPE = 'N' (for 'New'), then X is initialized with random values.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. If TRANS = 'N', LDX >= max(1,N); if TRANS = 'T', LDX >= max(1,M).
[out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vector(s) for the system of equations, computed from B = op(A) * X, where op(A) is determined by TRANS.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. If TRANS = 'N', LDB >= max(1,M); if TRANS = 'T', LDB >= max(1,N).
[in,out]	ISEED	ISEED is INTEGER array, dimension (4) The seed vector for the random number generator (used in ZLATMS). Modified on exit.
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -k, the k-th argument had an illegal value

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 209 of file zlarhs.f.

Here is the call graph for this function:

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name.
[in]	IMAT	IMAT is INTEGER An integer key describing which matrix to generate for this path.
[in]	M	M is INTEGER The number of rows in the matrix to be generated.
[in]	N	N is INTEGER The number of columns in the matrix to be generated.
[out]	TYPE	TYPE is CHARACTER*1 The type of the matrix to be generated: = 'S': symmetric matrix = 'P': symmetric positive (semi)definite matrix = 'N': nonsymmetric matrix
[out]	KL	KL is INTEGER The lower band width of the matrix to be generated.
[out]	KU	KU is INTEGER The upper band width of the matrix to be generated.
[out]	ANORM	ANORM is DOUBLE PRECISION The desired norm of the matrix to be generated. The diagonal matrix of singular values or eigenvalues is scaled by this value.
[out]	MODE	MODE is INTEGER A key indicating how to choose the vector of eigenvalues.
[out]	CNDNUM	CNDNUM is DOUBLE PRECISION The desired condition number.
[out]	DIST	DIST is CHARACTER*1 The type of distribution to be used by the random number generator.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 120 of file zlatb4.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	PATH	PATH is CHARACTER*3 The LAPACK path name.
[in]	IMAT	IMAT is INTEGER An integer key describing which matrix to generate for this path.
[in]	N	N is INTEGER The number of rows and columns in the matrix to be generated.
[out]	TYPE	TYPE is CHARACTER*1 The type of the matrix to be generated: = 'S': symmetric matrix = 'P': symmetric positive (semi)definite matrix = 'N': nonsymmetric matrix
[out]	KL	KL is INTEGER The lower band width of the matrix to be generated.
[out]	KU	KU is INTEGER The upper band width of the matrix to be generated.
[out]	ANORM	ANORM is DOUBLE PRECISION The desired norm of the matrix to be generated. The diagonal matrix of singular values or eigenvalues is scaled by this value.
[out]	MODE	MODE is INTEGER A key indicating how to choose the vector of eigenvalues.
[out]	CNDNUM	CNDNUM is DOUBLE PRECISION The desired condition number.
[out]	DIST	DIST is CHARACTER*1 The type of distribution to be used by the random number generator.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 114 of file zlatb5.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER Specifies whether the generated matrix is to be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The dimension of the matrix to be generated.
[out]	X	X is COMPLEX*16 array, dimension (N*(N+1)/2) The generated matrix in packed storage format. The matrix consists of 3x3 and 2x2 diagonal blocks which result in the pivot sequence given above. The matrix outside these diagonal blocks is zero.
[in,out]	ISEED	ISEED is INTEGER array, dimension (4) On entry, the seed for the random number generator. The last of the four integers must be odd. (modified on exit)

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 85 of file zlatsp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER Specifies whether the generated matrix is to be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The dimension of the matrix to be generated.
[out]	X	X is COMPLEX*16 array, dimension (LDX,N) The generated matrix, consisting of 3x3 and 2x2 diagonal blocks which result in the pivot sequence given above. The matrix outside of these diagonal blocks is zero.
[in]	LDX	LDX is INTEGER The leading dimension of the array X.
[in,out]	ISEED	ISEED is INTEGER array, dimension (4) On entry, the seed for the random number generator. The last of the four integers must be odd. (modified on exit)

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 90 of file zlatsy.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	IMAT	IMAT is INTEGER An integer key describing which matrix to generate for this path.
[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the matrix A will be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular
[in]	TRANS	TRANS is CHARACTER*1 Specifies whether the matrix or its transpose will be used. = 'N': No transpose = 'T': Transpose = 'C': Conjugate transpose (= transpose)
[out]	DIAG	DIAG is CHARACTER*1 Specifies whether or not the matrix A is unit triangular. = 'N': Non-unit triangular = 'U': Unit triangular
[in,out]	ISEED	ISEED is INTEGER array, dimension (4) The seed vector for the random number generator (used in ZLATMS). Modified on exit.
[in]	N	N is INTEGER The order of the matrix to be generated.
[in]	KD	KD is INTEGER The number of superdiagonals or subdiagonals of the banded triangular matrix A. KD >= 0.
[out]	AB	AB is COMPLEX*16 array, dimension (LDAB,N) The upper or lower triangular banded matrix A, stored in the first KD+1 rows of AB. Let j be a column of A, 1<=j<=n. If UPLO = 'U', AB(kd+1+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).
[in]	LDAB	LDAB is INTEGER The leading dimension of the array AB. LDAB >= KD+1.
[out]	B	B is COMPLEX*16 array, dimension (N)
[out]	WORK	WORK is COMPLEX*16 array, dimension (2*N)
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 141 of file zlattb.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	IMAT	IMAT is INTEGER An integer key describing which matrix to generate for this path.
[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the matrix A will be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular
[in]	TRANS	TRANS is CHARACTER*1 Specifies whether the matrix or its transpose will be used. = 'N': No transpose = 'T': Transpose = 'C': Conjugate transpose
[out]	DIAG	DIAG is CHARACTER*1 Specifies whether or not the matrix A is unit triangular. = 'N': Non-unit triangular = 'U': Unit triangular
[in,out]	ISEED	ISEED is INTEGER array, dimension (4) The seed vector for the random number generator (used in ZLATMS). Modified on exit.
[in]	N	N is INTEGER The order of the matrix to be generated.
[out]	AP	AP is COMPLEX*16 array, dimension (N*(N+1)/2) The upper or lower triangular matrix A, packed columnwise in a linear array. The 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.
[out]	B	B is COMPLEX*16 array, dimension (N) The right hand side vector, if IMAT > 10.
[out]	WORK	WORK is COMPLEX*16 array, dimension (2*N)
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 131 of file zlattp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	IMAT	IMAT is INTEGER An integer key describing which matrix to generate for this path.
[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the matrix A will be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular
[in]	TRANS	TRANS is CHARACTER*1 Specifies whether the matrix or its transpose will be used. = 'N': No transpose = 'T': Transpose = 'C': Conjugate transpose
[out]	DIAG	DIAG is CHARACTER*1 Specifies whether or not the matrix A is unit triangular. = 'N': Non-unit triangular = 'U': Unit triangular
[in,out]	ISEED	ISEED is INTEGER array, dimension (4) The seed vector for the random number generator (used in ZLATMS). Modified on exit.
[in]	N	N is INTEGER The order of the matrix to be generated.
[out]	A	A is COMPLEX*16 array, dimension (LDA,N) The triangular matrix A. If UPLO = 'U', the leading N x N upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N x N lower triangular part of the array A contains the lower triangular matrix and the strictly upper triangular part of A is not referenced.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).
[out]	B	B is COMPLEX*16 array, dimension (N) The right hand side vector, if IMAT > 10.
[out]	WORK	WORK is COMPLEX*16 array, dimension (2*N)
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 138 of file zlattr.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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 symmetric factorization computed by ZHETRF.
    ZHETRF produces a factorization of the form
         U * D * U^H     or     L * D * L^H,
    where U (or L) is a product of permutation and unit upper (lower)
    triangular matrices, U^H (or L^H) is the conjugate transpose of
    U (or L), and D is Hermitian and block diagonal with 1 x 1 and
    2 x 2 diagonal blocks.  The multipliers for the transformations
    and the upper or lower triangular parts of the diagonal blocks
    are stored in the leading upper or lower triangle of the 2-D
    array A.

    If TRANS = 'N' or 'n', ZLAVHE multiplies either by U or U * D
    (or L or L * D).
    If TRANS = 'C' or 'c', ZLAVHE multiplies either by U^H or D * U^H
    (or L^H or D * L^H ).

  UPLO   - CHARACTER*1
           On entry, UPLO specifies whether the triangular matrix
           stored in A is upper or lower triangular.
              UPLO = 'U' or 'u'   The matrix is upper triangular.
              UPLO = 'L' or 'l'   The matrix is lower triangular.
           Unchanged on exit.

  TRANS  - CHARACTER*1
           On entry, TRANS specifies the operation to be performed as
           follows:
              TRANS = 'N' or 'n'   x := A*x.
              TRANS = 'C' or 'c'   x := A^H*x.
           Unchanged on exit.

  DIAG   - CHARACTER*1
           On entry, DIAG specifies whether the diagonal blocks are
           assumed to be unit matrices:
              DIAG = 'U' or 'u'   Diagonal blocks are unit matrices.
              DIAG = 'N' or 'n'   Diagonal blocks are 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( LDA, N )
           On entry, A contains a block diagonal matrix and the
           multipliers of the transformations used to obtain it,
           stored as a 2-D triangular matrix.
           Unchanged on exit.

  LDA    - INTEGER
           On entry, LDA specifies the first dimension of A as declared
           in the calling ( sub ) program. LDA must be at least
           max( 1, N ).
           Unchanged on exit.

  IPIV   - INTEGER array, dimension( N )
           On entry, IPIV contains the vector of pivot indices as
           determined by ZSYTRF or ZHETRF.
           If IPIV( K ) = K, no interchange was done.
           If IPIV( K ) <> K but IPIV( K ) > 0, then row K was inter-
           changed with row IPIV( K ) and a 1 x 1 pivot block was used.
           If IPIV( K ) < 0 and UPLO = 'U', then row 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

Definition at line 138 of file zlavhe.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 131 of file zlavhp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 131 of file zlavsp.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the factor stored in A is upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular
[in]	TRANS	TRANS is CHARACTER*1 Specifies the operation to be performed: = 'N': x := A*x = 'T': x := A'*x
[in]	DIAG	DIAG is CHARACTER*1 Specifies whether or not the diagonal blocks are unit matrices. If the diagonal blocks are assumed to be unit, then A = U or A = L, otherwise A = U*D or A = L*D. = 'U': Diagonal blocks are assumed to be unit matrices. = 'N': Diagonal blocks are assumed to be non-unit matrices.
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of right hand sides, i.e., the number of vectors x to be multiplied by A. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The block diagonal matrix D and the multipliers used to obtain the factor U or L as computed by ZSYTRF.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).
[in]	IPIV	IPIV is INTEGER array, dimension (N) Details of the interchanges and the block structure of D, as determined by ZSYTRF or ZHETRF. If UPLO = 'U': If IPIV(k) > 0, then rows and columns k and IPIV(k) were interchanged and D(k,k) is a 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.
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, B contains NRHS vectors of length N. On exit, B is overwritten with the product A * B.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]	INFO	INFO is INTEGER = 0: successful exit < 0: if INFO = -k, the k-th argument had an illegal value

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

Definition at line 152 of file zlavsy.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The m-by-n matrix A.
[out]	AF	AF is COMPLEX*16 array, dimension (LDA,N) Details of the LQ factorization of A, as returned by ZGELQF. See ZGELQF for further details.
[out]	Q	Q is COMPLEX*16 array, dimension (LDA,N) The n-by-n orthogonal matrix Q.
[out]	L	L is COMPLEX*16 array, dimension (LDA,max(M,N))
[in]	LDA	LDA is INTEGER The leading dimension of the arrays A, AF, Q and L. LDA >= max(M,N).
[out]	TAU	TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by ZGELQF.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The dimension of the array WORK.
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (max(M,N))
[out]	RESULT	RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( L - A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 126 of file zlqt01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix Q to be generated. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix Q to be generated. N >= M >= 0.
[in]	K	K is INTEGER The number of elementary reflectors whose product defines the matrix Q. M >= K >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The m-by-n matrix A which was factorized by ZLQT01.
[in]	AF	AF is COMPLEX*16 array, dimension (LDA,N) Details of the LQ factorization of A, as returned by ZGELQF. See ZGELQF for further details.
[out]	Q	Q is COMPLEX*16 array, dimension (LDA,N)
[out]	L	L is COMPLEX*16 array, dimension (LDA,M)
[in]	LDA	LDA is INTEGER The leading dimension of the arrays A, AF, Q and L. LDA >= N.
[in]	TAU	TAU is COMPLEX*16 array, dimension (M) The scalar factors of the elementary reflectors corresponding to the LQ factorization in AF.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The dimension of the array WORK.
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (M)
[out]	RESULT	RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( L - A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I - Q*Q' ) / ( N * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 135 of file zlqt02.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	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.
[in]	N	N is INTEGER The order of the orthogonal matrix Q. N >= 0.
[in]	K	K is INTEGER The number of elementary reflectors whose product defines the orthogonal matrix Q. N >= K >= 0.
[in]	AF	AF is COMPLEX*16 array, dimension (LDA,N) Details of the LQ factorization of an m-by-n matrix, as returned by ZGELQF. See CGELQF for further details.
[out]	C	C is COMPLEX*16 array, dimension (LDA,N)
[out]	CC	CC is COMPLEX*16 array, dimension (LDA,N)
[out]	Q	Q is COMPLEX*16 array, dimension (LDA,N)
[in]	LDA	LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q.
[in]	TAU	TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the LQ factorization in AF.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The length of WORK. LWORK must be at least M, and should be M*NB, where NB is the blocksize for this environment.
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (M)
[out]	RESULT	RESULT is DOUBLE PRECISION array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an 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

Definition at line 136 of file zlqt03.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	KD	KD is INTEGER The number of super-diagonals of the matrix A if UPLO = 'U', or the number of sub-diagonals if UPLO = 'L'. KD >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original Hermitian band matrix A. If UPLO = 'U', the upper triangular part of A is stored as a band matrix; if UPLO = 'L', the lower triangular part of A is stored. The columns of the appropriate triangle are stored in the columns of A and the diagonals of the triangle are stored in the rows of A. See ZPBTRF for further details.
[in]	LDA	LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,KD+1).
[in]	AFAC	AFAC is COMPLEX*16 array, dimension (LDAFAC,N) The factored form of the matrix A. AFAC contains the factor L or U from the L*L' or U'*U factorization in band storage format, as computed by ZPBTRF.
[in]	LDAFAC	LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,KD+1).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RESID	RESID is DOUBLE PRECISION If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 120 of file zpbt01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	KD	KD is INTEGER The number of super-diagonals of the matrix A if UPLO = 'U', or the number of sub-diagonals if UPLO = 'L'. KD >= 0.
[in]	NRHS	NRHS is INTEGER The number of right hand sides. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original Hermitian band matrix A. If UPLO = 'U', the upper triangular part of A is stored as a band matrix; if UPLO = 'L', the lower triangular part of A is stored. The columns of the appropriate triangle are stored in the columns of A and the diagonals of the triangle are stored in the rows of A. See ZPBTRF for further details.
[in]	LDA	LDA is INTEGER. The leading dimension of the array A. LDA >= max(1,KD+1).
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B - A*X.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RESID	RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 136 of file zpbt02.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored. = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0.
[in]	KD	KD is INTEGER The number of super-diagonals of the matrix A if UPLO = 'U', or the number of sub-diagonals if UPLO = 'L'. KD >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0.
[in]	AB	AB is COMPLEX*16 array, dimension (LDAB,N) The upper or lower triangle of the Hermitian band matrix A, stored in the first KD+1 rows of the array. The 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).
[in]	LDAB	LDAB is INTEGER The leading dimension of the array AB. LDAB >= KD+1.
[in]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[in]	XACT	XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT.
[in]	LDXACT	LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N).
[in]	FERR	FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X - XTRUE) divided by the magnitude of the largest entry in X.
[in]	BERR	BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution).
[out]	RESLTS	RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 171 of file zpbt05.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original Hermitian matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N)
[in,out]	AFAC	AFAC is COMPLEX*16 array, dimension (LDAFAC,N) On entry, the factor L or U from the L*L' or U'*U factorization of A. Overwritten with the reconstructed matrix, and then with the difference L*L' - A (or U'*U - A).
[in]	LDAFAC	LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RESID	RESID is DOUBLE PRECISION If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 107 of file zpot01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original Hermitian matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N)
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B - A*X.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RESID	RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 127 of file zpot02.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original Hermitian matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N)
[in,out]	AINV	AINV is COMPLEX*16 array, dimension (LDAINV,N) On entry, the inverse of the matrix A, stored as a Hermitian matrix in the same format as A. In this version, AINV is expanded into a full matrix and multiplied by A, so the opposing triangle of AINV will be changed; i.e., if the upper triangular part of AINV is stored, the lower triangular part will be used as work space.
[in]	LDAINV	LDAINV is INTEGER The leading dimension of the array AINV. LDAINV >= max(1,N).
[out]	WORK	WORK is COMPLEX*16 array, dimension (LDWORK,N)
[in]	LDWORK	LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RCOND	RCOND is DOUBLE PRECISION The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV).
[out]	RESID	RESID is DOUBLE PRECISION norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 126 of file zpot03.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored. = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The Hermitian matrix A. If UPLO = 'U', the leading n by n upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading n by n lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).
[in]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[in]	XACT	XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT.
[in]	LDXACT	LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N).
[in]	FERR	FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X - XTRUE) divided by the magnitude of the largest entry in X.
[in]	BERR	BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution).
[out]	RESLTS	RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( (n+1)*EPS + (*) )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 165 of file zpot05.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the symmetric matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original M x N matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N).
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. If TRANS = 'N', LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,N).
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B - A*X.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. IF TRANS = 'N', LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RESID	RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 127 of file zpot06.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	A	A is COMPLEX*16 array, dimension (N*(N+1)/2) The original Hermitian matrix A, stored as a packed triangular matrix.
[in,out]	AFAC	AFAC is COMPLEX*16 array, dimension (N*(N+1)/2) On entry, the factor L or U from the L*L' or U'*U factorization of A, stored as a packed triangular matrix. Overwritten with the reconstructed matrix, and then with the difference L*L' - A (or U'*U - A).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RESID	RESID is DOUBLE PRECISION If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 96 of file zppt01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (N*(N+1)/2) The original Hermitian matrix A, stored as a packed triangular matrix.
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B - A*X.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RESID	RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 123 of file zppt02.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	A	A is COMPLEX*16 array, dimension (N*(N+1)/2) The original Hermitian matrix A, stored as a packed triangular matrix.
[in]	AINV	AINV is COMPLEX*16 array, dimension (N*(N+1)/2) The (Hermitian) inverse of the matrix A, stored as a packed triangular matrix.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LDWORK,N)
[in]	LDWORK	LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RCOND	RCOND is DOUBLE PRECISION The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV).
[out]	RESID	RESID is DOUBLE PRECISION norm(I - A*AINV) / ( N * norm(A) * norm(AINV) * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 110 of file zppt03.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored. = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0.
[in]	AP	AP is COMPLEX*16 array, dimension (N*(N+1)/2) The upper or lower triangle of the Hermitian matrix A, packed columnwise in a linear array. The 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.
[in]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[in]	XACT	XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT.
[in]	LDXACT	LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N).
[in]	FERR	FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X - XTRUE) divided by the magnitude of the largest entry in X.
[in]	BERR	BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution).
[out]	RESLTS	RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( (n+1)*EPS + (*) )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 157 of file zppt05.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular
[in]	N	N is INTEGER The number of rows and columns of the matrix A. N >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original Hermitian matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,N)
[in]	AFAC	AFAC is COMPLEX*16 array, dimension (LDAFAC,N) The factor L or U from the L*L' or U'*U factorization of A.
[in]	LDAFAC	LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,N).
[out]	PERM	PERM is COMPLEX*16 array, dimension (LDPERM,N) Overwritten with the reconstructed matrix, and then with the difference P*L*L'*P' - A (or P*U'*U*P' - A)
[in]	LDPERM	LDPERM is INTEGER The leading dimension of the array PERM. LDAPERM >= max(1,N).
[in]	PIV	PIV is INTEGER array, dimension (N) PIV is such that the nonzero entries are P( PIV( K ), K ) = 1.
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (N)
[out]	RESID	RESID is DOUBLE PRECISION If UPLO = 'L', norm(L*L' - A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U - A) / ( N * norm(A) * EPS )
[in]	RANK	RANK is INTEGER number of nonzero singular values of A.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 136 of file zpst01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	N	N is INTEGTER The order of the matrix A.
[in]	D	D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix A.
[in]	E	E is COMPLEX*16 array, dimension (N-1) The (n-1) subdiagonal elements of the tridiagonal matrix A.
[in]	DF	DF is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the factor L from the L*D*L' factorization of A.
[in]	EF	EF is COMPLEX*16 array, dimension (N-1) The (n-1) subdiagonal elements of the factor L from the L*D*L' factorization of A.
[out]	WORK	WORK is COMPLEX*16 array, dimension (2*N)
[out]	RESID	RESID is DOUBLE PRECISION norm(L*D*L' - A) / (n * norm(A) * EPS)

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 93 of file zptt01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	UPLO	UPLO is CHARACTER*1 Specifies whether the superdiagonal or the subdiagonal of the tridiagonal matrix A is stored. = 'U': E is the superdiagonal of A = 'L': E is the subdiagonal of A
[in]	N	N is INTEGTER The order of the matrix A.
[in]	NRHS	NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0.
[in]	D	D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix A.
[in]	E	E is COMPLEX*16 array, dimension (N-1) The (n-1) subdiagonal elements of the tridiagonal matrix A.
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The n by nrhs matrix of solution vectors X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the n by nrhs matrix of right hand side vectors B. On exit, B is overwritten with the difference B - A*X.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[out]	RESID	RESID is DOUBLE PRECISION norm(B - A*X) / (norm(A) * norm(X) * EPS)

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 116 of file zptt02.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	N	N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0.
[in]	D	D is DOUBLE PRECISION array, dimension (N) The n diagonal elements of the tridiagonal matrix A.
[in]	E	E is COMPLEX*16 array, dimension (N-1) The (n-1) subdiagonal elements of the tridiagonal matrix A.
[in]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) The right hand side vectors for the system of linear equations.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N).
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors. Each vector is stored as a column of the matrix X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. LDX >= max(1,N).
[in]	XACT	XACT is COMPLEX*16 array, dimension (LDX,NRHS) The exact solution vectors. Each vector is stored as a column of the matrix XACT.
[in]	LDXACT	LDXACT is INTEGER The leading dimension of the array XACT. LDXACT >= max(1,N).
[in]	FERR	FERR is DOUBLE PRECISION array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X - XTRUE) divided by the magnitude of the largest entry in X.
[in]	BERR	BERR is DOUBLE PRECISION array, dimension (NRHS) The componentwise relative backward error of each solution vector (i.e., the smallest relative change in any entry of A or B that makes X an exact solution).
[out]	RESLTS	RESLTS is DOUBLE PRECISION array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X - XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 150 of file zptt05.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The m-by-n matrix A.
[out]	AF	AF is COMPLEX*16 array, dimension (LDA,N) Details of the QL factorization of A, as returned by ZGEQLF. See ZGEQLF for further details.
[out]	Q	Q is COMPLEX*16 array, dimension (LDA,M) The m-by-m orthogonal matrix Q.
[out]	L	L is COMPLEX*16 array, dimension (LDA,max(M,N))
[in]	LDA	LDA is INTEGER The leading dimension of the arrays A, AF, Q and R. LDA >= max(M,N).
[out]	TAU	TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by ZGEQLF.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The dimension of the array WORK.
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (M)
[out]	RESULT	RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( L - Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 126 of file zqlt01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix Q to be generated. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix Q to be generated. M >= N >= 0.
[in]	K	K is INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The m-by-n matrix A which was factorized by ZQLT01.
[in]	AF	AF is COMPLEX*16 array, dimension (LDA,N) Details of the QL factorization of A, as returned by ZGEQLF. See ZGEQLF for further details.
[out]	Q	Q is COMPLEX*16 array, dimension (LDA,N)
[out]	L	L is COMPLEX*16 array, dimension (LDA,N)
[in]	LDA	LDA is INTEGER The leading dimension of the arrays A, AF, Q and L. LDA >= M.
[in]	TAU	TAU is COMPLEX*16 array, dimension (N) The scalar factors of the elementary reflectors corresponding to the QL factorization in AF.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The dimension of the array WORK.
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (M)
[out]	RESULT	RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( L - Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 136 of file zqlt02.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The order of the orthogonal matrix Q. M >= 0.
[in]	N	N is INTEGER The number of rows or columns of the matrix C; C is m-by-n if Q is applied from the left, or n-by-m if Q is applied from the right. N >= 0.
[in]	K	K is INTEGER The number of elementary reflectors whose product defines the orthogonal matrix Q. M >= K >= 0.
[in]	AF	AF is COMPLEX*16 array, dimension (LDA,N) Details of the QL factorization of an m-by-n matrix, as returned by ZGEQLF. See CGEQLF for further details.
[out]	C	C is COMPLEX*16 array, dimension (LDA,N)
[out]	CC	CC is COMPLEX*16 array, dimension (LDA,N)
[out]	Q	Q is COMPLEX*16 array, dimension (LDA,M)
[in]	LDA	LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q.
[in]	TAU	TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the QL factorization in AF.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The length of WORK. LWORK must be at least M, and should be M*NB, where NB is the blocksize for this environment.
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (M)
[out]	RESULT	RESULT is DOUBLE PRECISION array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an 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

Definition at line 136 of file zqlt03.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrices A and AF.
[in]	N	N is INTEGER The number of columns of the matrices A and AF.
[in]	K	K is INTEGER The number of columns of AF that have been reduced to upper triangular form.
[in]	A	A is COMPLEX*16 array, dimension (LDA, N) The original matrix A.
[in]	AF	AF is COMPLEX*16 array, dimension (LDA,N) The (possibly partial) output of ZGEQPF. The upper triangle of AF(1:k,1:k) is a partial triangular factor, the entries below the diagonal in the first k columns are the Householder vectors, and the rest of AF contains a partially updated matrix.
[in]	LDA	LDA is INTEGER The leading dimension of the arrays A and AF.
[in]	TAU	TAU is COMPLEX*16 array, dimension (K) Details of the Householder transformations as returned by ZGEQPF.
[in]	JPVT	JPVT is INTEGER array, dimension (N) Pivot information as returned by ZGEQPF.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The length of the array WORK. LWORK >= M*N+N.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 120 of file zqpt01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The m-by-n matrix A.
[out]	AF	AF is COMPLEX*16 array, dimension (LDA,N) Details of the QR factorization of A, as returned by ZGEQRF. See ZGEQRF for further details.
[out]	Q	Q is COMPLEX*16 array, dimension (LDA,M) The m-by-m orthogonal matrix Q.
[out]	R	R is COMPLEX*16 array, dimension (LDA,max(M,N))
[in]	LDA	LDA is INTEGER The leading dimension of the arrays A, AF, Q and R. LDA >= max(M,N).
[out]	TAU	TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by ZGEQRF.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The dimension of the array WORK.
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (M)
[out]	RESULT	RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( R - Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 126 of file zqrt01.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The m-by-n matrix A.
[out]	AF	AF is COMPLEX*16 array, dimension (LDA,N) Details of the QR factorization of A, as returned by ZGEQRFP. See ZGEQRFP for further details.
[out]	Q	Q is COMPLEX*16 array, dimension (LDA,M) The m-by-m orthogonal matrix Q.
[out]	R	R is COMPLEX*16 array, dimension (LDA,max(M,N))
[in]	LDA	LDA is INTEGER The leading dimension of the arrays A, AF, Q and R. LDA >= max(M,N).
[out]	TAU	TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by ZGEQRFP.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The dimension of the array WORK.
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (M)
[out]	RESULT	RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( R - Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 126 of file zqrt01p.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix Q to be generated. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix Q to be generated. M >= N >= 0.
[in]	K	K is INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The m-by-n matrix A which was factorized by ZQRT01.
[in]	AF	AF is COMPLEX*16 array, dimension (LDA,N) Details of the QR factorization of A, as returned by ZGEQRF. See ZGEQRF for further details.
[out]	Q	Q is COMPLEX*16 array, dimension (LDA,N)
[out]	R	R is COMPLEX*16 array, dimension (LDA,N)
[in]	LDA	LDA is INTEGER The leading dimension of the arrays A, AF, Q and R. LDA >= M.
[in]	TAU	TAU is COMPLEX*16 array, dimension (N) The scalar factors of the elementary reflectors corresponding to the QR factorization in AF.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The dimension of the array WORK.
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (M)
[out]	RESULT	RESULT is DOUBLE PRECISION array, dimension (2) The test ratios: RESULT(1) = norm( R - Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I - Q'*Q ) / ( M * EPS )

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 135 of file zqrt02.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The order of the orthogonal matrix Q. M >= 0.
[in]	N	N is INTEGER The number of rows or columns of the matrix C; C is m-by-n if Q is applied from the left, or n-by-m if Q is applied from the right. N >= 0.
[in]	K	K is INTEGER The number of elementary reflectors whose product defines the orthogonal matrix Q. M >= K >= 0.
[in]	AF	AF is COMPLEX*16 array, dimension (LDA,N) Details of the QR factorization of an m-by-n matrix, as returnedby ZGEQRF. See CGEQRF for further details.
[out]	C	C is COMPLEX*16 array, dimension (LDA,N)
[out]	CC	CC is COMPLEX*16 array, dimension (LDA,N)
[out]	Q	Q is COMPLEX*16 array, dimension (LDA,M)
[in]	LDA	LDA is INTEGER The leading dimension of the arrays AF, C, CC, and Q.
[in]	TAU	TAU is COMPLEX*16 array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the QR factorization in AF.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The length of WORK. LWORK must be at least M, and should be M*NB, where NB is the blocksize for this environment.
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (M)
[out]	RESULT	RESULT is DOUBLE PRECISION array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an 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

Definition at line 136 of file zqrt03.f.

Here is the call graph for this function:

Here is the caller graph for this function:

subroutine zqrt04	(	integer	M,
		integer	N,
		integer	NB,
		double precision, dimension(6)	RESULT
	)

ZQRT04

Purpose:

 ZQRT04 tests ZGEQRT and ZGEMQRT.

Parameters:

[in]	M	M is INTEGER Number of rows in test matrix.
[in]	N	N is INTEGER Number of columns in test matrix.
[in]	NB	NB is INTEGER Block size of test matrix. NB <= Min(M,N).
[out]	RESULT	RESULT is DOUBLE PRECISION array, dimension (6) Results of each of the six tests below. RESULT(1) = | A - Q R | RESULT(2) = | I - Q^H Q | RESULT(3) = | Q C - Q C | RESULT(4) = | Q^H C - Q^H C | RESULT(5) = | C Q - C Q | RESULT(6) = | C Q^H - C Q^H |

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

Definition at line 74 of file zqrt04.f.

Here is the call graph for this function:

Here is the caller graph for this function:

subroutine zqrt05	(	integer	M,
		integer	N,
		integer	L,
		integer	NB,
		double precision, dimension(6)	RESULT
	)

ZQRT05

Purpose:

 ZQRT05 tests ZTPQRT and ZTPMQRT.

Parameters:

[in]	M	M is INTEGER Number of rows in lower part of the test matrix.
[in]	N	N is INTEGER Number of columns in test matrix.
[in]	L	L is INTEGER The number of rows of the upper trapezoidal part the lower test matrix. 0 <= L <= M.
[in]	NB	NB is INTEGER Block size of test matrix. NB <= N.
[out]	RESULT	RESULT is DOUBLE PRECISION array, dimension (6) Results of each of the six tests below. RESULT(1) = | A - Q R | RESULT(2) = | I - Q^H Q | RESULT(3) = | Q C - Q C | RESULT(4) = | Q^H C - Q^H C | RESULT(5) = | C Q - C Q | RESULT(6) = | C Q^H - C Q^H |

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

April 2012

Definition at line 81 of file zqrt05.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix A.
[in]	K	K is INTEGER The number of columns of A whose subdiagonal entries contain information about orthogonal transformations.
[in]	A	A is COMPLEX*16 array, dimension (LDA,K) The (possibly partial) output of a QR reduction routine.
[in]	LDA	LDA is INTEGER The leading dimension of the array A.
[in]	TAU	TAU is COMPLEX*16 array, dimension (K) The scaling factors tau for the elementary transformations as computed by the QR factorization routine.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The length of the array WORK. LWORK >= M*M + M.

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 99 of file zqrt11.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	M	M is INTEGER The number of rows of the matrix A.
[in]	N	N is INTEGER The number of columns of the matrix A.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The M-by-N matrix A. Only the upper trapezoid is referenced.
[in]	LDA	LDA is INTEGER The leading dimension of the array A.
[in]	S	S is DOUBLE PRECISION array, dimension (min(M,N)) The singular values of the matrix A.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER The length of the array WORK. LWORK >= M*N + 2*min(M,N) + max(M,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (2*min(M,N))

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 97 of file zqrt12.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	SCALE	SCALE is INTEGER SCALE = 1: normally scaled matrix SCALE = 2: matrix scaled up SCALE = 3: matrix scaled down
[in]	M	M is INTEGER The number of rows of the matrix A.
[in]	N	N is INTEGER The number of columns of A.
[out]	A	A is COMPLEX*16 array, dimension (LDA,N) The M-by-N matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A.
[out]	NORMA	NORMA is DOUBLE PRECISION The one-norm of A.
[in,out]	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

Definition at line 92 of file zqrt13.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	TRANS	TRANS is CHARACTER*1 = 'N': No transpose, check for X in the row space of A = 'C': Conjugate transpose, check for X in row space of A'.
[in]	M	M is INTEGER The number of rows of the matrix A.
[in]	N	N is INTEGER The number of columns of the matrix A.
[in]	NRHS	NRHS is INTEGER The number of right hand sides, i.e., the number of columns of X.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The M-by-N matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A.
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) If TRANS = 'N', the N-by-NRHS matrix X. IF TRANS = 'C', the M-by-NRHS matrix X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X.
[out]	WORK	WORK is COMPLEX*16 array dimension (LWORK)
[in]	LWORK	LWORK is INTEGER length of workspace array required If TRANS = 'N', LWORK >= (M+NRHS)*(N+2); if TRANS = 'C', LWORK >= (N+NRHS)*(M+2).

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 116 of file zqrt14.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	SCALE	SCALE is INTEGER SCALE = 1: normally scaled matrix SCALE = 2: matrix scaled up SCALE = 3: matrix scaled down
[in]	RKSEL	RKSEL is INTEGER RKSEL = 1: full rank matrix RKSEL = 2: rank-deficient matrix
[in]	M	M is INTEGER The number of rows of the matrix A.
[in]	N	N is INTEGER The number of columns of A.
[in]	NRHS	NRHS is INTEGER The number of columns of B.
[out]	A	A is COMPLEX*16 array, dimension (LDA,N) The M-by-N matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A.
[out]	B	B is COMPLEX*16 array, dimension (LDB, NRHS) A matrix that is in the range space of matrix A.
[in]	LDB	LDB is INTEGER The leading dimension of the array B.
[out]	S	S is DOUBLE PRECISION array, dimension MIN(M,N) Singular values of A.
[out]	RANK	RANK is INTEGER number of nonzero singular values of A.
[out]	NORMA	NORMA is DOUBLE PRECISION one-norm norm of A.
[out]	NORMB	NORMB is DOUBLE PRECISION one-norm norm of B.
[in,out]	ISEED	ISEED is integer array, dimension (4) seed for random number generator.
[out]	WORK	WORK is COMPLEX*16 array, dimension (LWORK)
[in]	LWORK	LWORK is INTEGER length of work space required. LWORK >= MAX(M+MIN(M,N),NRHS*MIN(M,N),2*N+M)

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 149 of file zqrt15.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	TRANS	TRANS is CHARACTER*1 Specifies the form of the system of equations: = 'N': A *x = b = 'T': A^T*x = b, where A^T is the transpose of A = 'C': A^H*x = b, where A^H is the conjugate transpose of A
[in]	M	M is INTEGER The number of rows of the matrix A. M >= 0.
[in]	N	N is INTEGER The number of columns of the matrix A. N >= 0.
[in]	NRHS	NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The original M x N matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= max(1,M).
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) The computed solution vectors for the system of linear equations.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. If TRANS = 'N', LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).
[in,out]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) On entry, the right hand side vectors for the system of linear equations. On exit, B is overwritten with the difference B - A*X.
[in]	LDB	LDB is INTEGER The leading dimension of the array B. IF TRANS = 'N', LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).
[out]	RWORK	RWORK is DOUBLE PRECISION array, dimension (M)
[out]	RESID	RESID is DOUBLE PRECISION The maximum over the number of right hand sides of norm(B - A*X) / ( max(m,n) * norm(A) * norm(X) * EPS ).

Author:

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Date:

November 2011

Definition at line 133 of file zqrt16.f.

Here is the call graph for this function:

Here is the caller graph for this function:

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:

[in]	TRANS	TRANS is CHARACTER*1 Specifies whether or not the transpose of A is used. = 'N': No transpose, op(A) = A. = 'C': Conjugate transpose, op(A) = A'.
[in]	IRESID	IRESID is INTEGER IRESID = 1 indicates zero-residual problem. IRESID = 2 indicates non-zero residual.
[in]	M	M is INTEGER The number of rows of the matrix A. If TRANS = 'N', the number of rows of the matrix B. If TRANS = 'C', the number of rows of the matrix X.
[in]	N	N is INTEGER The number of columns of the matrix A. If TRANS = 'N', the number of rows of the matrix X. If TRANS = 'C', the number of rows of the matrix B.
[in]	NRHS	NRHS is INTEGER The number of columns of the matrices X and B.
[in]	A	A is COMPLEX*16 array, dimension (LDA,N) The m-by-n matrix A.
[in]	LDA	LDA is INTEGER The leading dimension of the array A. LDA >= M.
[in]	X	X is COMPLEX*16 array, dimension (LDX,NRHS) If TRANS = 'N', the n-by-nrhs matrix X. If TRANS = 'C', the m-by-nrhs matrix X.
[in]	LDX	LDX is INTEGER The leading dimension of the array X. If TRANS = 'N', LDX >= N. If TRANS = 'C', LDX >= M.
[in]	B	B is COMPLEX*16 array, dimension (LDB,NRHS) If T