LAPACK
3.4.2
LAPACK: Linear Algebra PACKage

Functions/Subroutines  
program  cchkaa 
CCHKAA  
subroutine  cchkeq (THRESH, NOUT) 
CCHKEQ  
subroutine  cchkgb (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, A, LA, AFAC, LAFAC, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
CCHKGB  
subroutine  cchkge (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
CCHKGE  
subroutine  cchkgt (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
CCHKGT  
subroutine  cchkhe (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
CCHKHE  
subroutine  cchkhp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
CCHKHP  
subroutine  cchklq (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR, NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, NOUT) 
CCHKLQ  
subroutine  cchkpb (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, NOUT) 
CCHKPB  
subroutine  cchkpo (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, NOUT) 
CCHKPO  
subroutine  cchkpp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, NOUT) 
CCHKPP  
subroutine  cchkps (DOTYPE, NN, NVAL, NNB, NBVAL, NRANK, RANKVAL, THRESH, TSTERR, NMAX, A, AFAC, PERM, PIV, WORK, RWORK, NOUT) 
CCHKPS  
subroutine  cchkpt (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, A, D, E, B, X, XACT, WORK, RWORK, NOUT) 
CCHKPT  
subroutine  cchkq3 (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, THRESH, A, COPYA, S, TAU, WORK, RWORK, IWORK, NOUT) 
CCHKQ3  
subroutine  cchkql (DOTYPE, NM, MVAL, NN, NVAL, NNB, NBVAL, NXVAL, NRHS, THRESH, TSTERR, NMAX, A, AF, AQ, AL, AC, B, X, XACT, TAU, WORK, RWORK, NOUT) 
CCHKQL  
subroutine  cchkqp (DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR, A, COPYA, S, TAU, WORK, RWORK, IWORK, NOUT) 
CCHKQP  
subroutine  cchkqr (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) 
CCHKQR  
subroutine  cchkqrt (THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT) 
CCHKQRT  
subroutine  cchkqrtp (THRESH, TSTERR, NM, MVAL, NN, NVAL, NNB, NBVAL, NOUT) 
CCHKQRTP  
program  cchkrfp 
CCHKRFP  
subroutine  cchkrq (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) 
CCHKRQ  
subroutine  cchksp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
CCHKSP  
subroutine  cchksy (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
CCHKSY  
subroutine  cchktb (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AB, AINV, B, X, XACT, WORK, RWORK, NOUT) 
CCHKTB  
subroutine  cchktp (DOTYPE, NN, NVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, AP, AINVP, B, X, XACT, WORK, RWORK, NOUT) 
CCHKTP  
subroutine  cchktr (DOTYPE, NN, NVAL, NNB, NBVAL, NNS, NSVAL, THRESH, TSTERR, NMAX, A, AINV, B, X, XACT, WORK, RWORK, NOUT) 
CCHKTR  
subroutine  cchktz (DOTYPE, NM, MVAL, NN, NVAL, THRESH, TSTERR, A, COPYA, S, TAU, WORK, RWORK, NOUT) 
CCHKTZ  
subroutine  cdrvgb (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, LA, AFB, LAFB, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT) 
CDRVGB  
subroutine  cdrvge (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, IWORK, NOUT) 
CDRVGE  
subroutine  cdrvgt (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, AF, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
CDRVGT  
subroutine  cdrvhe (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
CDRVHE  
subroutine  cdrvhp (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
CDRVHP  
subroutine  cdrvls (DOTYPE, NM, MVAL, NN, NVAL, NNS, NSVAL, NNB, NBVAL, NXVAL, THRESH, TSTERR, A, COPYA, B, COPYB, C, S, COPYS, WORK, RWORK, IWORK, NOUT) 
CDRVLS  
subroutine  cdrvpb (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, NOUT) 
CDRVPB  
subroutine  cdrvpo (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, NOUT) 
CDRVPO  
subroutine  cdrvpp (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, ASAV, B, BSAV, X, XACT, S, WORK, RWORK, NOUT) 
CDRVPP  
subroutine  cdrvpt (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, A, D, E, B, X, XACT, WORK, RWORK, NOUT) 
CDRVPT  
subroutine  cdrvrf1 (NOUT, NN, NVAL, THRESH, A, LDA, ARF, WORK) 
CDRVRF1  
subroutine  cdrvrf2 (NOUT, NN, NVAL, A, LDA, ARF, AP, ASAV) 
CDRVRF2  
subroutine  cdrvrf3 (NOUT, NN, NVAL, THRESH, A, LDA, ARF, B1, B2, S_WORK_CLANGE, C_WORK_CGEQRF, TAU) 
CDRVRF3  
subroutine  cdrvrf4 (NOUT, NN, NVAL, THRESH, C1, C2, LDC, CRF, A, LDA, S_WORK_CLANGE) 
CDRVRF4  
subroutine  cdrvrfp (NOUT, NN, NVAL, NNS, NSVAL, NNT, NTVAL, THRESH, A, ASAV, AFAC, AINV, B, BSAV, XACT, X, ARF, ARFINV, C_WORK_CLATMS, C_WORK_CPOT02, C_WORK_CPOT03, S_WORK_CLATMS, S_WORK_CLANHE, S_WORK_CPOT01, S_WORK_CPOT02, S_WORK_CPOT03) 
CDRVRFP  
subroutine  cdrvsp (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
CDRVSP  
subroutine  cdrvsy (DOTYPE, NN, NVAL, NRHS, THRESH, TSTERR, NMAX, A, AFAC, AINV, B, X, XACT, WORK, RWORK, IWORK, NOUT) 
CDRVSY  
subroutine  cebchvxx (THRESH, PATH) 
CEBCHVXX  
subroutine  cerrge (PATH, NUNIT) 
CERRGE  
subroutine  cerrgt (PATH, NUNIT) 
CERRGT  
subroutine  cerrhe (PATH, NUNIT) 
CERRHE  
subroutine  cerrlq (PATH, NUNIT) 
CERRLQ  
subroutine  cerrls (PATH, NUNIT) 
CERRLS  
subroutine  cerrpo (PATH, NUNIT) 
CERRPO  
subroutine  cerrps (PATH, NUNIT) 
CERRPS  
subroutine  cerrql (PATH, NUNIT) 
CERRQL  
subroutine  cerrqp (PATH, NUNIT) 
CERRQP  
subroutine  cerrqr (PATH, NUNIT) 
CERRQR  
subroutine  cerrqrt (PATH, NUNIT) 
CERRQRT  
subroutine  cerrqrtp (PATH, NUNIT) 
CERRQRTP  
subroutine  cerrrfp (NUNIT) 
CERRRFP  
subroutine  cerrrq (PATH, NUNIT) 
CERRRQ  
subroutine  cerrsy (PATH, NUNIT) 
CERRSY  
subroutine  cerrtr (PATH, NUNIT) 
CERRTR  
subroutine  cerrtz (PATH, NUNIT) 
CERRTZ  
subroutine  cerrvx (PATH, NUNIT) 
CERRVX  
subroutine  cgbt01 (M, N, KL, KU, A, LDA, AFAC, LDAFAC, IPIV, WORK, RESID) 
CGBT01  
subroutine  cgbt02 (TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, RESID) 
CGBT02  
subroutine  cgbt05 (TRANS, N, KL, KU, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
CGBT05  
subroutine  cgelqs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO) 
CGELQS  
LOGICAL function  cgennd (M, N, A, LDA) 
CGENND  
subroutine  cgeqls (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO) 
CGEQLS  
subroutine  cgeqrs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO) 
CGEQRS  
subroutine  cgerqs (M, N, NRHS, A, LDA, TAU, B, LDB, WORK, LWORK, INFO) 
CGERQS  
subroutine  cget01 (M, N, A, LDA, AFAC, LDAFAC, IPIV, RWORK, RESID) 
CGET01  
subroutine  cget02 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
CGET02  
subroutine  cget03 (N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID) 
CGET03  
subroutine  cget04 (N, NRHS, X, LDX, XACT, LDXACT, RCOND, RESID) 
CGET04  
subroutine  cget07 (TRANS, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, CHKFERR, BERR, RESLTS) 
CGET07  
subroutine  cgtt01 (N, DL, D, DU, DLF, DF, DUF, DU2, IPIV, WORK, LDWORK, RWORK, RESID) 
CGTT01  
subroutine  cgtt02 (TRANS, N, NRHS, DL, D, DU, X, LDX, B, LDB, RESID) 
CGTT02  
subroutine  cgtt05 (TRANS, N, NRHS, DL, D, DU, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
CGTT05  
subroutine  chet01 (UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID) 
CHET01  
subroutine  chkxer (SRNAMT, INFOT, NOUT, LERR, OK) 
CHKXER  
subroutine  chpt01 (UPLO, N, A, AFAC, IPIV, C, LDC, RWORK, RESID) 
CHPT01  
subroutine  clahilb (N, NRHS, A, LDA, X, LDX, B, LDB, WORK, INFO, PATH) 
CLAHILB  
subroutine  claipd (N, A, INDA, VINDA) 
CLAIPD  
subroutine  claptm (UPLO, N, NRHS, ALPHA, D, E, X, LDX, BETA, B, LDB) 
CLAPTM  
subroutine  clarhs (PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB, ISEED, INFO) 
CLARHS  
subroutine  clatb4 (PATH, IMAT, M, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST) 
CLATB4  
subroutine  clatb5 (PATH, IMAT, N, TYPE, KL, KU, ANORM, MODE, CNDNUM, DIST) 
CLATB5  
subroutine  clatsp (UPLO, N, X, ISEED) 
CLATSP  
subroutine  clatsy (UPLO, N, X, LDX, ISEED) 
CLATSY  
subroutine  clattb (IMAT, UPLO, TRANS, DIAG, ISEED, N, KD, AB, LDAB, B, WORK, RWORK, INFO) 
CLATTB  
subroutine  clattp (IMAT, UPLO, TRANS, DIAG, ISEED, N, AP, B, WORK, RWORK, INFO) 
CLATTP  
subroutine  clattr (IMAT, UPLO, TRANS, DIAG, ISEED, N, A, LDA, B, WORK, RWORK, INFO) 
CLATTR  
subroutine  clavhe (UPLO, TRANS, DIAG, N, NRHS, A, LDA, IPIV, B, LDB, INFO) 
CLAVHE  
subroutine  clavhp (UPLO, TRANS, DIAG, N, NRHS, A, IPIV, B, LDB, INFO) 
CLAVHP  
subroutine  clavsp (UPLO, TRANS, DIAG, N, NRHS, A, IPIV, B, LDB, INFO) 
CLAVSP  
subroutine  clavsy (UPLO, TRANS, DIAG, N, NRHS, A, LDA, IPIV, B, LDB, INFO) 
CLAVSY  
subroutine  clqt01 (M, N, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
CLQT01  
subroutine  clqt02 (M, N, K, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
CLQT02  
subroutine  clqt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
CLQT03  
subroutine  cpbt01 (UPLO, N, KD, A, LDA, AFAC, LDAFAC, RWORK, RESID) 
CPBT01  
subroutine  cpbt02 (UPLO, N, KD, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
CPBT02  
subroutine  cpbt05 (UPLO, N, KD, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
CPBT05  
subroutine  cpot01 (UPLO, N, A, LDA, AFAC, LDAFAC, RWORK, RESID) 
CPOT01  
subroutine  cpot02 (UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
CPOT02  
subroutine  cpot03 (UPLO, N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID) 
CPOT03  
subroutine  cpot05 (UPLO, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
CPOT05  
subroutine  cppt01 (UPLO, N, A, AFAC, RWORK, RESID) 
CPPT01  
subroutine  cppt02 (UPLO, N, NRHS, A, X, LDX, B, LDB, RWORK, RESID) 
CPPT02  
subroutine  cppt03 (UPLO, N, A, AINV, WORK, LDWORK, RWORK, RCOND, RESID) 
CPPT03  
subroutine  cppt05 (UPLO, N, NRHS, AP, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
CPPT05  
subroutine  cpst01 (UPLO, N, A, LDA, AFAC, LDAFAC, PERM, LDPERM, PIV, RWORK, RESID, RANK) 
CPST01  
subroutine  cptt01 (N, D, E, DF, EF, WORK, RESID) 
CPTT01  
subroutine  cptt02 (UPLO, N, NRHS, D, E, X, LDX, B, LDB, RESID) 
CPTT02  
subroutine  cptt05 (N, NRHS, D, E, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
CPTT05  
subroutine  cqlt01 (M, N, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
CQLT01  
subroutine  cqlt02 (M, N, K, A, AF, Q, L, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
CQLT02  
subroutine  cqlt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
CQLT03  
REAL function  cqpt01 (M, N, K, A, AF, LDA, TAU, JPVT, WORK, LWORK) 
CQPT01  
subroutine  cqrt01 (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
CQRT01  
subroutine  cqrt01p (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
CQRT01P  
subroutine  cqrt02 (M, N, K, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
CQRT02  
subroutine  cqrt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
CQRT03  
subroutine  cqrt04 (M, N, NB, RESULT) 
CQRT04  
subroutine  cqrt05 (M, N, L, NB, RESULT) 
CQRT05  
REAL function  cqrt11 (M, K, A, LDA, TAU, WORK, LWORK) 
CQRT11  
REAL function  cqrt12 (M, N, A, LDA, S, WORK, LWORK, RWORK) 
CQRT12  
subroutine  cqrt13 (SCALE, M, N, A, LDA, NORMA, ISEED) 
CQRT13  
REAL function  cqrt14 (TRANS, M, N, NRHS, A, LDA, X, LDX, WORK, LWORK) 
CQRT14  
subroutine  cqrt15 (SCALE, RKSEL, M, N, NRHS, A, LDA, B, LDB, S, RANK, NORMA, NORMB, ISEED, WORK, LWORK) 
CQRT15  
subroutine  cqrt16 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
CQRT16  
REAL function  cqrt17 (TRANS, IRESID, M, N, NRHS, A, LDA, X, LDX, B, LDB, C, WORK, LWORK) 
CQRT17  
subroutine  crqt01 (M, N, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
CRQT01  
subroutine  crqt02 (M, N, K, A, AF, Q, R, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
CRQT02  
subroutine  crqt03 (M, N, K, AF, C, CC, Q, LDA, TAU, WORK, LWORK, RWORK, RESULT) 
CRQT03  
REAL function  crzt01 (M, N, A, AF, LDA, TAU, WORK, LWORK) 
CRZT01  
REAL function  crzt02 (M, N, AF, LDA, TAU, WORK, LWORK) 
CRZT02  
subroutine  csbmv (UPLO, N, K, ALPHA, A, LDA, X, INCX, BETA, Y, INCY) 
CSBMV  
subroutine  cspt01 (UPLO, N, A, AFAC, IPIV, C, LDC, RWORK, RESID) 
CSPT01  
subroutine  cspt02 (UPLO, N, NRHS, A, X, LDX, B, LDB, RWORK, RESID) 
CSPT02  
subroutine  cspt03 (UPLO, N, A, AINV, WORK, LDW, RWORK, RCOND, RESID) 
CSPT03  
subroutine  csyt01 (UPLO, N, A, LDA, AFAC, LDAFAC, IPIV, C, LDC, RWORK, RESID) 
CSYT01  
subroutine  csyt02 (UPLO, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID) 
CSYT02  
subroutine  csyt03 (UPLO, N, A, LDA, AINV, LDAINV, WORK, LDWORK, RWORK, RCOND, RESID) 
CSYT03  
subroutine  ctbt02 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, X, LDX, B, LDB, WORK, RWORK, RESID) 
CTBT02  
subroutine  ctbt03 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, SCALE, CNORM, TSCAL, X, LDX, B, LDB, WORK, RESID) 
CTBT03  
subroutine  ctbt05 (UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
CTBT05  
subroutine  ctbt06 (RCOND, RCONDC, UPLO, DIAG, N, KD, AB, LDAB, RWORK, RAT) 
CTBT06  
subroutine  ctpt01 (UPLO, DIAG, N, AP, AINVP, RCOND, RWORK, RESID) 
CTPT01  
subroutine  ctpt02 (UPLO, TRANS, DIAG, N, NRHS, AP, X, LDX, B, LDB, WORK, RWORK, RESID) 
CTPT02  
subroutine  ctpt03 (UPLO, TRANS, DIAG, N, NRHS, AP, SCALE, CNORM, TSCAL, X, LDX, B, LDB, WORK, RESID) 
CTPT03  
subroutine  ctpt05 (UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
CTPT05  
subroutine  ctpt06 (RCOND, RCONDC, UPLO, DIAG, N, AP, RWORK, RAT) 
CTPT06  
subroutine  ctrt01 (UPLO, DIAG, N, A, LDA, AINV, LDAINV, RCOND, RWORK, RESID) 
CTRT01  
subroutine  ctrt02 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, X, LDX, B, LDB, WORK, RWORK, RESID) 
CTRT02  
subroutine  ctrt03 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, SCALE, CNORM, TSCAL, X, LDX, B, LDB, WORK, RESID) 
CTRT03  
subroutine  ctrt05 (UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X, LDX, XACT, LDXACT, FERR, BERR, RESLTS) 
CTRT05  
subroutine  ctrt06 (RCOND, RCONDC, UPLO, DIAG, N, A, LDA, RWORK, RAT) 
CTRT06  
REAL function  ctzt01 (M, N, A, AF, LDA, TAU, WORK, LWORK) 
CTZT01  
REAL function  ctzt02 (M, N, AF, LDA, TAU, WORK, LWORK) 
CTZT02 
This is the group of complex LAPACK TESTING LIN routines.
program cchkaa  (  ) 
CCHKAA
CCHKAA is the main test program for the COMPLEX linear equation routines. The program must be driven by a short data file. The first 15 records (not including the first comment line) specify problem dimensions and program options using listdirected input. The remaining lines specify the LAPACK test paths and the number of matrix types to use in testing. An annotated example of a data file can be obtained by deleting the first 3 characters from the following 42 lines: Data file for testing COMPLEX 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 CGE 11 List types on next line if 0 < NTYPES < 11 CGB 8 List types on next line if 0 < NTYPES < 8 CGT 12 List types on next line if 0 < NTYPES < 12 CPO 9 List types on next line if 0 < NTYPES < 9 CPO 9 List types on next line if 0 < NTYPES < 9 CPP 9 List types on next line if 0 < NTYPES < 9 CPB 8 List types on next line if 0 < NTYPES < 8 CPT 12 List types on next line if 0 < NTYPES < 12 CHE 10 List types on next line if 0 < NTYPES < 10 CHP 10 List types on next line if 0 < NTYPES < 10 CSY 11 List types on next line if 0 < NTYPES < 11 CSR 11 List types on next line if 0 < NTYPES < 11 CSP 11 List types on next line if 0 < NTYPES < 11 CTR 18 List types on next line if 0 < NTYPES < 18 CTP 18 List types on next line if 0 < NTYPES < 18 CTB 17 List types on next line if 0 < NTYPES < 17 CQR 8 List types on next line if 0 < NTYPES < 8 CRQ 8 List types on next line if 0 < NTYPES < 8 CLQ 8 List types on next line if 0 < NTYPES < 8 CQL 8 List types on next line if 0 < NTYPES < 8 CQP 6 List types on next line if 0 < NTYPES < 6 CTZ 3 List types on next line if 0 < NTYPES < 3 CLS 6 List types on next line if 0 < NTYPES < 6 CEQ CQT CQX
NMAX INTEGER The maximum allowable value for M and N. MAXIN INTEGER The number of different values that can be used for each of M, N, NRHS, NB, NX and RANK MAXRHS INTEGER The maximum number of right hand sides MATMAX INTEGER The maximum number of matrix types to use for testing NIN INTEGER The unit number for input NOUT INTEGER The unit number for output
Definition at line 109 of file cchkaa.f.
subroutine cchkeq  (  real  THRESH, 
integer  NOUT  
) 
CCHKEQ
CCHKEQ tests CGEEQU, CGBEQU, CPOEQU, CPPEQU and CPBEQU
[in]  THRESH  THRESH is REAL Threshold for testing routines. Should be between 2 and 10. 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 55 of file cchkeq.f.
subroutine cchkgb  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
complex, dimension( * )  A,  
integer  LA,  
complex, dimension( * )  AFAC,  
integer  LAFAC,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CCHKGB
CCHKGB tests CGBTRF, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (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 REAL 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 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 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 array, dimension (NMAX*NSMAX) 
[out]  X  X is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NSMAX,NMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 190 of file cchkgb.f.
subroutine cchkge  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CCHKGE
CCHKGE tests CGETRF, TRI, TRS, RFS, and CON.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(2*NMAX,2*NSMAX+NWORK)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 185 of file cchkge.f.
subroutine cchkgt  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
complex, dimension( * )  A,  
complex, dimension( * )  AF,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CCHKGT
CCHKGT tests CGTTRF, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*4) 
[out]  AF  AF is COMPLEX array, dimension (NMAX*4) 
[out]  B  B is COMPLEX array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX)+2*NSMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 147 of file cchkgt.f.
subroutine cchkhe  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CCHKHE
CCHKHE tests CHETRF, TRI2, TRS, TRS2, RFS, and CON.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 172 of file cchkhe.f.
subroutine cchkhp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CCHKHP
CCHKHP tests CHPTRF, TRI, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(2,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NSMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 163 of file cchkhp.f.
subroutine cchklq  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AF,  
complex, dimension( * )  AQ,  
complex, dimension( * )  AL,  
complex, dimension( * )  AC,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  TAU,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CCHKLQ
CCHKLQ tests CGELQF, CUNGLQ and CUNMLQ.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AF  AF is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AL  AL is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AC  AC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is COMPLEX array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 195 of file cchklq.f.
subroutine cchkpb  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CCHKPB
CCHKPB tests CPBTRF, TRS, RFS, and CON.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL 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 REAL array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is REAL array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is REAL array, dimension (NMAX*NMAX) 
[out]  B  B is REAL array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is REAL array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is REAL array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is REAL array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 167 of file cchkpb.f.
subroutine cchkpo  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CCHKPO
CCHKPO tests CPOTRF, TRI, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NSMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 167 of file cchkpo.f.
subroutine cchkpp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CCHKPP
CCHKPP tests CPPTRF, TRI, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 158 of file cchkpp.f.
subroutine cchkps  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NRANK,  
integer, dimension( * )  RANKVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  PERM,  
integer, dimension( * )  PIV,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CCHKPS
CCHKPS tests CPSTRF.
[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 REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  PERM  PERM is COMPLEX array, dimension (NMAX*NMAX) 
[out]  PIV  PIV is INTEGER array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*3) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 153 of file cchkps.f.
subroutine cchkpt  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
complex, dimension( * )  A,  
real, dimension( * )  D,  
complex, dimension( * )  E,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CCHKPT
CCHKPT tests CPTTRF, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*2) 
[out]  D  D is REAL array, dimension (NMAX*2) 
[out]  E  E is COMPLEX array, dimension (NMAX*2) 
[out]  B  B is COMPLEX array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 147 of file cchkpt.f.
subroutine cchkq3  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
real  THRESH,  
complex, dimension( * )  A,  
complex, dimension( * )  COPYA,  
real, dimension( * )  S,  
complex, dimension( * )  TAU,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CCHKQ3
CCHKQ3 tests CGEQP3.
[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 REAL 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 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 array, dimension (MMAX*NMAX) 
[out]  S  S is REAL array, dimension (min(MMAX,NMAX)) 
[out]  TAU  TAU is COMPLEX array, dimension (MMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (max(M*max(M,N) + 4*min(M,N) + max(M,N))) 
[out]  RWORK  RWORK is REAL array, dimension (4*NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 157 of file cchkq3.f.
subroutine cchkql  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AF,  
complex, dimension( * )  AQ,  
complex, dimension( * )  AL,  
complex, dimension( * )  AC,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  TAU,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CCHKQL
CCHKQL tests CGEQLF, CUNGQL and CUNMQL.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AF  AF is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AL  AL is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AC  AC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is COMPLEX array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 195 of file cchkql.f.
subroutine cchkqp  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
real  THRESH,  
logical  TSTERR,  
complex, dimension( * )  A,  
complex, dimension( * )  COPYA,  
real, dimension( * )  S,  
complex, dimension( * )  TAU,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CCHKQP
CCHKQP tests CGEQPF.
[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 REAL 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 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 array, dimension (MMAX*NMAX) 
[out]  S  S is REAL array, dimension (min(MMAX,NMAX)) 
[out]  TAU  TAU is COMPLEX array, dimension (MMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (max(M*max(M,N) + 4*min(M,N) + max(M,N))) 
[out]  RWORK  RWORK is REAL array, dimension (4*NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 143 of file cchkqp.f.
subroutine cchkqr  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AF,  
complex, dimension( * )  AQ,  
complex, dimension( * )  AR,  
complex, dimension( * )  AC,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  TAU,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CCHKQR
CCHKQR tests CGEQRF, CUNGQR and CUNMQR.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AF  AF is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AR  AR is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AC  AC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is COMPLEX array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 200 of file cchkqr.f.
subroutine cchkqrt  (  real  THRESH, 
logical  TSTERR,  
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NOUT  
) 
CCHKQRT
CCHKQRT tests CGEQRT and CGEMQRT.
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 102 of file cchkqrt.f.
subroutine cchkqrtp  (  real  THRESH, 
logical  TSTERR,  
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NOUT  
) 
CCHKQRTP
CCHKQRTP tests CTPQRT and CTPMQRT.
[in]  THRESH  THRESH is REAL The threshold value for the test ratios. A result is included in the output file if RESULT >= THRESH. To have every test ratio printed, use THRESH = 0. 
[in]  TSTERR  TSTERR is LOGICAL Flag that indicates whether error exits are to be tested. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 102 of file cchkqrtp.f.
program cchkrfp  (  ) 
CCHKRFP
CCHKRFP is the main test program for the COMPLEX linear equation routines with RFP storage format
MAXIN INTEGER The number of different values that can be used for each of M, N, or NB MAXRHS INTEGER The maximum number of right hand sides NTYPES INTEGER NMAX INTEGER The maximum allowable value for N. NIN INTEGER The unit number for input NOUT INTEGER The unit number for output
Definition at line 60 of file cchkrfp.f.
subroutine cchkrq  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer, dimension( * )  NXVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AF,  
complex, dimension( * )  AQ,  
complex, dimension( * )  AR,  
complex, dimension( * )  AC,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  TAU,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CCHKRQ
CCHKRQ tests CGERQF, CUNGRQ and CUNMRQ.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AF  AF is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AQ  AQ is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AR  AR is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AC  AC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  TAU  TAU is COMPLEX array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*NMAX) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 200 of file cchkrq.f.
subroutine cchksp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CCHKSP
CCHKSP tests CSPTRF, TRI, TRS, RFS, and CON
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(2,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NSMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 163 of file cchksp.f.
subroutine cchksy  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CCHKSY
CCHKSY tests CSYTRF, TRI2, TRS, TRS2, RFS, and CON.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB contained in the vector NBVAL. 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NBVAL) The values of the blocksize NB. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(2,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NSMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 172 of file cchksy.f.
subroutine cchktb  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  AB,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CCHKTB
CCHKTB tests CTBTRS, RFS, and CON, and CLATBS.
[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 REAL 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 array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 149 of file cchktb.f.
subroutine cchktp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  AP,  
complex, dimension( * )  AINVP,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CCHKTP
CCHKTP tests CTPTRI, TRS, RFS, and CON, and CLATPS
[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 REAL 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 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINVP  AINVP is COMPLEX array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 150 of file cchktp.f.
subroutine cchktr  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NNB,  
integer, dimension( * )  NBVAL,  
integer  NNS,  
integer, dimension( * )  NSVAL,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CCHKTR
CCHKTR tests CTRTRI, TRS, RFS, and CON, and CLATRS
[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 REAL 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 array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NSMAX) where NSMAX is the largest entry in NSVAL. 
[out]  X  X is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NSMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NSMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NSMAX)) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 162 of file cchktr.f.
subroutine cchktz  (  logical, dimension( * )  DOTYPE, 
integer  NM,  
integer, dimension( * )  MVAL,  
integer  NN,  
integer, dimension( * )  NVAL,  
real  THRESH,  
logical  TSTERR,  
complex, dimension( * )  A,  
complex, dimension( * )  COPYA,  
real, dimension( * )  S,  
complex, dimension( * )  TAU,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CCHKTZ
CCHKTZ tests CTZRQF and CTZRZF.
[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 REAL 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 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 array, dimension (MMAX*NMAX) 
[out]  S  S is REAL array, dimension (min(MMAX,NMAX)) 
[out]  TAU  TAU is COMPLEX array, dimension (MMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (MMAX*NMAX + 4*NMAX + MMAX) 
[out]  RWORK  RWORK is REAL array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 137 of file cchktz.f.
subroutine cdrvgb  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
complex, dimension( * )  A,  
integer  LA,  
complex, dimension( * )  AFB,  
integer  LAFB,  
complex, dimension( * )  ASAV,  
complex, dimension( * )  B,  
complex, dimension( * )  BSAV,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
real, dimension( * )  S,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CDRVGB
CDRVGBX
CDRVGB tests the driver routines CGBSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (LA) 
[in]  LA  LA is INTEGER The length of the array A. LA >= (2*NMAX1)*NMAX where NMAX is the largest entry in NVAL. 
[out]  AFB  AFB is COMPLEX array, dimension (LAFB) 
[in]  LAFB  LAFB is INTEGER The length of the array AFB. LAFB >= (3*NMAX2)*NMAX where NMAX is the largest entry in NVAL. 
[out]  ASAV  ASAV is COMPLEX array, dimension (LA) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (2*NMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NRHS,NMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NRHS)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
CDRVGB tests the driver routines CGBSV, SVX, and SVXX. Note that this file is used only when the XBLAS are available, otherwise cdrvgb.f defines this subroutine.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (LA) 
[in]  LA  LA is INTEGER The length of the array A. LA >= (2*NMAX1)*NMAX where NMAX is the largest entry in NVAL. 
[out]  AFB  AFB is COMPLEX array, dimension (LAFB) 
[in]  LAFB  LAFB is INTEGER The length of the array AFB. LAFB >= (3*NMAX2)*NMAX where NMAX is the largest entry in NVAL. 
[out]  ASAV  ASAV is COMPLEX array, dimension (LA) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (2*NMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NRHS,NMAX)) 
[out]  RWORK  RWORK is REAL array, dimension (max(NMAX,2*NRHS)) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 171 of file cdrvgb.f.
subroutine cdrvge  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  ASAV,  
complex, dimension( * )  B,  
complex, dimension( * )  BSAV,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
real, dimension( * )  S,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CDRVGE
CDRVGEX
CDRVGE tests the driver routines CGESV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (2*NMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (2*NRHS+NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
CDRVGE tests the driver routines CGESV, SVX, and SVXX. Note that this file is used only when the XBLAS are available, otherwise cdrvge.f defines this subroutine.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (2*NMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (2*NRHS+NMAX) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 163 of file cdrvge.f.
subroutine cdrvgt  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
complex, dimension( * )  A,  
complex, dimension( * )  AF,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CDRVGT
CDRVGT tests CGTSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, NRHS >= 0. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*4) 
[out]  AF  AF is COMPLEX array, dimension (NMAX*4) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (2*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 139 of file cdrvgt.f.
subroutine cdrvhe  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CDRVHE
CDRVHEX
CDRVHE tests the driver routines CHESV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
CDRVHE tests the driver routines CHESV, SVX, and SVXX. Note that this file is used only when the XBLAS are available, otherwise cdrvhe.f defines this subroutine.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (2*NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 153 of file cdrvhe.f.
subroutine cdrvhp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CDRVHP
CDRVHP tests the driver routines CHPSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 156 of file cdrvhp.f.
subroutine cdrvls  (  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,  
real  THRESH,  
logical  TSTERR,  
complex, dimension( * )  A,  
complex, dimension( * )  COPYA,  
complex, dimension( * )  B,  
complex, dimension( * )  COPYB,  
complex, dimension( * )  C,  
real, dimension( * )  S,  
real, dimension( * )  COPYS,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CDRVLS
CDRVLS tests the least squares driver routines CGELS, CGELSX, CGELSS, CGELSY and CGELSD.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. The matrix of type j is generated as follows: j=1: A = U*D*V where U and V are random unitary matrices and D has random entries (> 0.1) taken from a uniform distribution (0,1). A is full rank. j=2: The same of 1, but A is scaled up. j=3: The same of 1, but A is scaled down. j=4: A = U*D*V where U and V are random unitary matrices and D has 3*min(M,N)/4 random entries (> 0.1) taken from a uniform distribution (0,1) and the remaining entries set to 0. A is rankdeficient. j=5: The same of 4, but A is scaled up. j=6: The same of 5, but A is scaled down. 
[in]  NM  NM is INTEGER The number of values of M contained in the vector MVAL. 
[in]  MVAL  MVAL is INTEGER array, dimension (NM) The values of the matrix row dimension M. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix column dimension N. 
[in]  NNB  NNB is INTEGER The number of values of NB and NX contained in the vectors NBVAL and NXVAL. The blocking parameters are used in pairs (NB,NX). 
[in]  NBVAL  NBVAL is INTEGER array, dimension (NNB) The values of the blocksize NB. 
[in]  NXVAL  NXVAL is INTEGER array, dimension (NNB) The values of the crossover point NX. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of right hand sides NRHS. 
[in]  THRESH  THRESH is REAL 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 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 array, dimension (MMAX*NMAX) 
[out]  B  B is COMPLEX 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 array, dimension (MMAX*NSMAX) 
[out]  C  C is COMPLEX array, dimension (MMAX*NSMAX) 
[out]  S  S is REAL array, dimension (min(MMAX,NMAX)) 
[out]  COPYS  COPYS is REAL array, dimension (min(MMAX,NMAX)) 
[out]  WORK  WORK is COMPLEX array, dimension (MMAX*NMAX + 4*NMAX + MMAX). 
[out]  RWORK  RWORK is REAL array, dimension (5*NMAX1) 
[out]  IWORK  IWORK is INTEGER array, dimension (15*NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 209 of file cdrvls.f.
subroutine cdrvpb  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  ASAV,  
complex, dimension( * )  B,  
complex, dimension( * )  BSAV,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
real, dimension( * )  S,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CDRVPB
CDRVPB tests the driver routines CPBSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 158 of file cdrvpb.f.
subroutine cdrvpo  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  ASAV,  
complex, dimension( * )  B,  
complex, dimension( * )  BSAV,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
real, dimension( * )  S,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CDRVPO
CDRVPOX
CDRVPO tests the driver routines CPOSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
CDRVPO tests the driver routines CPOSV, SVX, and SVXX. Note that this file is used only when the XBLAS are available, otherwise cdrvpo.f defines this subroutine.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 158 of file cdrvpo.f.
subroutine cdrvpp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  ASAV,  
complex, dimension( * )  B,  
complex, dimension( * )  BSAV,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
real, dimension( * )  S,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CDRVPP
CDRVPP tests the driver routines CPPSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*(NMAX+1)/2) 
[out]  ASAV  ASAV is COMPLEX array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  BSAV  BSAV is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  S  S is REAL array, dimension (NMAX) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 158 of file cdrvpp.f.
subroutine cdrvpt  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
complex, dimension( * )  A,  
real, dimension( * )  D,  
complex, dimension( * )  E,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  NOUT  
) 
CDRVPT
CDRVPT tests CPTSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*2) 
[out]  D  D is REAL array, dimension (NMAX*2) 
[out]  E  E is COMPLEX array, dimension (NMAX*2) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(3,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 140 of file cdrvpt.f.
subroutine cdrvrf1  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
real  THRESH,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( * )  ARF,  
real, dimension( * )  WORK  
) 
CDRVRF1
CDRVRF1 tests the LAPACK RFP routines: CLANHF.F
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  THRESH  THRESH is REAL 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 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 array, dimension ((NMAX*(NMAX+1))/2). 
[out]  WORK  WORK is COMPLEX array, dimension ( NMAX ) 
Definition at line 96 of file cdrvrf1.f.
subroutine cdrvrf2  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( * )  ARF,  
complex, dimension(*)  AP,  
complex, dimension( lda, * )  ASAV  
) 
CDRVRF2
CDRVRF2 tests the LAPACK RFP convertion routines.
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[out]  A  A is COMPLEX 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 array, dimension ((NMAX*(NMAX+1))/2). 
[out]  AP  AP is COMPLEX array, dimension ((NMAX*(NMAX+1))/2). 
[out]  ASAV  ASAV is COMPLEX6 array, dimension (LDA,NMAX) 
Definition at line 90 of file cdrvrf2.f.
subroutine cdrvrf3  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
real  THRESH,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( * )  ARF,  
complex, dimension( lda, * )  B1,  
complex, dimension( lda, * )  B2,  
real, dimension( * )  S_WORK_CLANGE,  
complex, dimension( * )  C_WORK_CGEQRF,  
complex, dimension( * )  TAU  
) 
CDRVRF3
CDRVRF3 tests the LAPACK RFP routines: CTFSM
[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 array, dimension ((NMAX*(NMAX+1))/2). 
[out]  B1  B1 is COMPLEX array, dimension (LDA,NMAX) 
[out]  B2  B2 is COMPLEX array, dimension (LDA,NMAX) 
[out]  S_WORK_CLANGE  S_WORK_CLANGE is REAL array, dimension (NMAX) 
[out]  C_WORK_CGEQRF  C_WORK_CGEQRF is COMPLEX array, dimension (NMAX) 
[out]  TAU  TAU is COMPLEX array, dimension (NMAX) 
Definition at line 119 of file cdrvrf3.f.
subroutine cdrvrf4  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
real  THRESH,  
complex, dimension( ldc, * )  C1,  
complex, dimension( ldc, *)  C2,  
integer  LDC,  
complex, dimension( * )  CRF,  
complex, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( * )  S_WORK_CLANGE  
) 
CDRVRF4
CDRVRF4 tests the LAPACK RFP routines: CHFRK
[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 REAL 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 array, dimension (LDC,NMAX) 
[out]  C2  C2 is COMPLEX 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 array, dimension ((NMAX*(NMAX+1))/2). 
[out]  A  A is COMPLEX array, dimension (LDA,NMAX) 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= max(1,NMAX). 
[out]  S_WORK_CLANGE  S_WORK_CLANGE is REAL array, dimension (NMAX) 
Definition at line 114 of file cdrvrf4.f.
subroutine cdrvrfp  (  integer  NOUT, 
integer  NN,  
integer, dimension( nn )  NVAL,  
integer  NNS,  
integer, dimension( nns )  NSVAL,  
integer  NNT,  
integer, dimension( nnt )  NTVAL,  
real  THRESH,  
complex, dimension( * )  A,  
complex, dimension( * )  ASAV,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  BSAV,  
complex, dimension( * )  XACT,  
complex, dimension( * )  X,  
complex, dimension( * )  ARF,  
complex, dimension( * )  ARFINV,  
complex, dimension( * )  C_WORK_CLATMS,  
complex, dimension( * )  C_WORK_CPOT02,  
complex, dimension( * )  C_WORK_CPOT03,  
real, dimension( * )  S_WORK_CLATMS,  
real, dimension( * )  S_WORK_CLANHE,  
real, dimension( * )  S_WORK_CPOT01,  
real, dimension( * )  S_WORK_CPOT02,  
real, dimension( * )  S_WORK_CPOT03  
) 
CDRVRFP
CDRVRFP tests the LAPACK RFP routines: CPFTRF, CPFTRS, and CPFTRI. This testing routine follow the same tests as CDRVPO (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 CTRTTF and CTFTTR. 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 CPFTRF, no test ratios are computed) A solution XACT of size NbyNRHS is created and the associated right hand side B as well. Then CPFTRF is called to compute L (or U), the Cholesky factor of A. Then L (or U) is used to solve the linear system of equations AX = B. This gives X. Then L (or U) is used to compute the inverse of A, AINV. The following four tests are then performed: (1) norm( L*L'  A ) / ( N * norm(A) * EPS ) or norm( U'*U  A ) / ( N * norm(A) * EPS ), (2) norm(B  A*X) / ( norm(A) * norm(X) * EPS ), (3) norm( I  A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ), (4) ( norm(XXACT) * RCOND ) / ( norm(XACT) * EPS ), where EPS is the machine precision, RCOND the condition number of A, and norm( . ) the 1norm for (1,2,3) and the infnorm for (4). Errors occur when INFO parameter is not as expected. Failures occur when a test ratios is greater than THRES.
[in]  NOUT  NOUT is INTEGER The unit number for output. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NNS  NNS is INTEGER The number of values of NRHS contained in the vector NSVAL. 
[in]  NSVAL  NSVAL is INTEGER array, dimension (NNS) The values of the number of righthand sides NRHS. 
[in]  NNT  NNT is INTEGER The number of values of MATRIX TYPE contained in the vector NTVAL. 
[in]  NTVAL  NTVAL is INTEGER array, dimension (NNT) The values of matrix type (between 0 and 9 for PO/PP/PF matrices). 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  ASAV  ASAV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*MAXRHS) 
[out]  BSAV  BSAV is COMPLEX array, dimension (NMAX*MAXRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*MAXRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*MAXRHS) 
[out]  ARF  ARF is COMPLEX array, dimension ((NMAX*(NMAX+1))/2) 
[out]  ARFINV  ARFINV is COMPLEX array, dimension ((NMAX*(NMAX+1))/2) 
[out]  C_WORK_CLATMS  C_WORK_CLATMS is COMPLEX array, dimension ( 3*NMAX ) 
[out]  C_WORK_CPOT02  C_WORK_CPOT02 is COMPLEX array, dimension ( NMAX*MAXRHS ) 
[out]  C_WORK_CPOT03  C_WORK_CPOT03 is COMPLEX array, dimension ( NMAX*NMAX ) 
[out]  S_WORK_CLATMS  S_WORK_CLATMS is REAL array, dimension ( NMAX ) 
[out]  S_WORK_CLANHE  S_WORK_CLANHE is REAL array, dimension ( NMAX ) 
[out]  S_WORK_CPOT01  S_WORK_CPOT01 is REAL array, dimension ( NMAX ) 
[out]  S_WORK_CPOT02  S_WORK_CPOT02 is REAL array, dimension ( NMAX ) 
[out]  S_WORK_CPOT03  S_WORK_CPOT03 is REAL array, dimension ( NMAX ) 
Definition at line 240 of file cdrvrfp.f.
subroutine cdrvsp  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CDRVSP
CDRVSP tests the driver routines CSPSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*(NMAX+1)/2) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*(NMAX+1)/2) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*(NMAX+1)/2) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 156 of file cdrvsp.f.
subroutine cdrvsy  (  logical, dimension( * )  DOTYPE, 
integer  NN,  
integer, dimension( * )  NVAL,  
integer  NRHS,  
real  THRESH,  
logical  TSTERR,  
integer  NMAX,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
complex, dimension( * )  AINV,  
complex, dimension( * )  B,  
complex, dimension( * )  X,  
complex, dimension( * )  XACT,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer, dimension( * )  IWORK,  
integer  NOUT  
) 
CDRVSY
CDRVSYX
CDRVSY tests the driver routines CSYSV and SVX.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
CDRVSY tests the driver routines CSYSV, SVX, and SVXX. Note that this file is used only when the XBLAS are available, otherwise cdrvsy.f defines this subroutine.
[in]  DOTYPE  DOTYPE is LOGICAL array, dimension (NTYPES) The matrix types to be used for testing. Matrices of type j (for 1 <= j <= NTYPES) are used for testing if DOTYPE(j) = .TRUE.; if DOTYPE(j) = .FALSE., then type j is not used. 
[in]  NN  NN is INTEGER The number of values of N contained in the vector NVAL. 
[in]  NVAL  NVAL is INTEGER array, dimension (NN) The values of the matrix dimension N. 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors to be generated for each linear system. 
[in]  THRESH  THRESH is REAL 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 array, dimension (NMAX*NMAX) 
[out]  AFAC  AFAC is COMPLEX array, dimension (NMAX*NMAX) 
[out]  AINV  AINV is COMPLEX array, dimension (NMAX*NMAX) 
[out]  B  B is COMPLEX array, dimension (NMAX*NRHS) 
[out]  X  X is COMPLEX array, dimension (NMAX*NRHS) 
[out]  XACT  XACT is COMPLEX array, dimension (NMAX*NRHS) 
[out]  WORK  WORK is COMPLEX array, dimension (NMAX*max(2,NRHS)) 
[out]  RWORK  RWORK is REAL array, dimension (2*NMAX+2*NRHS) 
[out]  IWORK  IWORK is INTEGER array, dimension (NMAX) 
[in]  NOUT  NOUT is INTEGER The unit number for output. 
Definition at line 153 of file cdrvsy.f.
subroutine cebchvxx  (  real  THRESH, 
character*3  PATH  
) 
CEBCHVXX
Purpose:
CEBCHVXX will run CGESVXX on a series of Hilbert matrices and then compare the error bounds returned by CGESVXX to see if the returned answer indeed falls within those bounds. Eight test ratios will be computed. The tests will pass if they are .LT. THRESH. There are two cases that are determined by 1 / (SQRT( N ) * EPS). If that value is .LE. to the component wise reciprocal condition number, it uses the guaranteed case, other wise it uses the unguaranteed case. Test ratios: Let Xc be X_computed and Xt be X_truth. The norm used is the infinity norm. Let A be the guaranteed case and B be the unguaranteed case. 1. Normwise guaranteed forward error bound. A: norm ( abs( Xc  Xt ) / norm ( Xt ) .LE. ERRBND( *, nwise_i, bnd_i ) and ERRBND( *, nwise_i, bnd_i ) .LE. MAX(SQRT(N),10) * EPS. If these conditions are met, the test ratio is set to be ERRBND( *, nwise_i, bnd_i ) / MAX(SQRT(N), 10). Otherwise it is 1/EPS. B: For this case, CGESVXX should just return 1. If it is less than one, treat it the same as in 1A. Otherwise it fails. (Set test ratio to ERRBND( *, nwise_i, bnd_i ) * THRESH?) 2. Componentwise guaranteed forward error bound. A: norm ( abs( Xc(j)  Xt(j) ) ) / norm (Xt(j)) .LE. ERRBND( *, cwise_i, bnd_i ) for all j .AND. ERRBND( *, cwise_i, bnd_i ) .LE. MAX(SQRT(N), 10) * EPS. If these conditions are met, the test ratio is set to be ERRBND( *, cwise_i, bnd_i ) / MAX(SQRT(N), 10). Otherwise it is 1/EPS. B: Same as normwise test ratio. 3. Backwards error. A: The test ratio is set to BERR/EPS. B: Same test ratio. 4. Reciprocal condition number. A: A condition number is computed with Xt and compared with the one returned from CGESVXX. Let RCONDc be the RCOND returned by CGESVXX and RCONDt be the RCOND from the truth value. Test ratio is set to MAX(RCONDc/RCONDt, RCONDt/RCONDc). B: Test ratio is set to 1 / (EPS * RCONDc). 5. Reciprocal normwise condition number. A: The test ratio is set to MAX(ERRBND( *, nwise_i, cond_i ) / NCOND, NCOND / ERRBND( *, nwise_i, cond_i )). B: Test ratio is set to 1 / (EPS * ERRBND( *, nwise_i, cond_i )). 6. Reciprocal componentwise condition number. A: Test ratio is set to MAX(ERRBND( *, cwise_i, cond_i ) / CCOND, CCOND / ERRBND( *, cwise_i, cond_i )). B: Test ratio is set to 1 / (EPS * ERRBND( *, cwise_i, cond_i )). .. Parameters .. NMAX is determined by the largest number in the inverse of the hilbert matrix. Precision is exhausted when the largest entry in it is greater than 2 to the power of the number of bits in the fraction of the data type used plus one, which is 24 for single precision. NMAX should be 6 for single and 11 for double.
Definition at line 97 of file cebchvxx.f.
subroutine cerrge  (  character*3  PATH, 
integer  NUNIT  
) 
CERRGE
CERRGEX
CERRGE tests the error exits for the COMPLEX routines for general matrices.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
CERRGE tests the error exits for the COMPLEX routines for general matrices. Note that this file is used only when the XBLAS are available, otherwise cerrge.f defines this subroutine.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrge.f.
subroutine cerrgt  (  character*3  PATH, 
integer  NUNIT  
) 
CERRGT
CERRGT tests the error exits for the COMPLEX tridiagonal routines.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrgt.f.
subroutine cerrhe  (  character*3  PATH, 
integer  NUNIT  
) 
CERRHE
CERRHEX
CERRHE tests the error exits for the COMPLEX routines for Hermitian indefinite matrices.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
CERRHE tests the error exits for the COMPLEX routines for Hermitian indefinite matrices. Note that this file is used only when the XBLAS are available, otherwise cerrhe.f defines this subroutine.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrhe.f.
subroutine cerrlq  (  character*3  PATH, 
integer  NUNIT  
) 
CERRLQ
CERRLQ tests the error exits for the COMPLEX routines that use the LQ decomposition of a general matrix.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrlq.f.
subroutine cerrls  (  character*3  PATH, 
integer  NUNIT  
) 
CERRLS
CERRLS tests the error exits for the COMPLEX least squares driver routines (CGELS, CGELSS, CGELSX, CGELSY, CGELSD).
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrls.f.
subroutine cerrpo  (  character*3  PATH, 
integer  NUNIT  
) 
CERRPO
CERRPOX
CERRPO tests the error exits for the COMPLEX routines for Hermitian positive definite matrices.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
CERRPO tests the error exits for the COMPLEX routines for Hermitian positive definite matrices. Note that this file is used only when the XBLAS are available, otherwise cerrpo.f defines this subroutine.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrpo.f.
subroutine cerrps  (  character*3  PATH, 
integer  NUNIT  
) 
CERRPS
CERRPS tests the error exits for the COMPLEX routines for CPSTRF..
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrps.f.
subroutine cerrql  (  character*3  PATH, 
integer  NUNIT  
) 
CERRQL
CERRQL tests the error exits for the COMPLEX routines that use the QL decomposition of a general matrix.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrql.f.
subroutine cerrqp  (  character*3  PATH, 
integer  NUNIT  
) 
CERRQP
CERRQP tests the error exits for CGEQPF and CGEQP3.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 55 of file cerrqp.f.
subroutine cerrqr  (  character*3  PATH, 
integer  NUNIT  
) 
CERRQR
CERRQR tests the error exits for the COMPLEX routines that use the QR decomposition of a general matrix.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrqr.f.
subroutine cerrqrt  (  character*3  PATH, 
integer  NUNIT  
) 
CERRQRT
CERRQRT tests the error exits for the COMPLEX routines that use the QRT decomposition of a general matrix.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrqrt.f.
subroutine cerrqrtp  (  character*3  PATH, 
integer  NUNIT  
) 
CERRQRTP
CERRQRTP tests the error exits for the REAL routines that use the QRT decomposition of a triangularpentagonal matrix.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrqrtp.f.
subroutine cerrrfp  (  integer  NUNIT  ) 
CERRRFP
CERRRFP tests the error exits for the COMPLEX driver routines for solving linear systems of equations. CDRVRFP tests the COMPLEX LAPACK RFP routines: CTFSM, CTFTRI, CHFRK, CTFTTP, CTFTTR, CPFTRF, CPFTRS, CTPTTF, CTPTTR, CTRTTF, and CTRTTP
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 53 of file cerrrfp.f.
subroutine cerrrq  (  character*3  PATH, 
integer  NUNIT  
) 
CERRRQ
CERRRQ tests the error exits for the COMPLEX routines that use the RQ decomposition of a general matrix.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrrq.f.
subroutine cerrsy  (  character*3  PATH, 
integer  NUNIT  
) 
CERRSY
CERRSYX
CERRSY tests the error exits for the COMPLEX routines for symmetric indefinite matrices.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
CERRSY tests the error exits for the COMPLEX routines for symmetric indefinite matrices. Note that this file is used only when the XBLAS are available, otherwise cerrsy.f defines this subroutine.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrsy.f.
subroutine cerrtr  (  character*3  PATH, 
integer  NUNIT  
) 
CERRTR
CERRTR tests the error exits for the COMPLEX triangular routines.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 55 of file cerrtr.f.
subroutine cerrtz  (  character*3  PATH, 
integer  NUNIT  
) 
CERRTZ
CERRTZ tests the error exits for CTZRQF and CTZRZF.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 55 of file cerrtz.f.
subroutine cerrvx  (  character*3  PATH, 
integer  NUNIT  
) 
CERRVX
CERRVXX
CERRVX tests the error exits for the COMPLEX driver routines for solving linear systems of equations.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
CERRVX tests the error exits for the COMPLEX driver routines for solving linear systems of equations.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name for the routines to be tested. 
[in]  NUNIT  NUNIT is INTEGER The unit number for output. 
Definition at line 56 of file cerrvx.f.
subroutine cgbt01  (  integer  M, 
integer  N,  
integer  KL,  
integer  KU,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
integer, dimension( * )  IPIV,  
complex, dimension( * )  WORK,  
real  RESID  
) 
CGBT01
CGBT01 reconstructs a band matrix A from its L*U factorization and computes the residual: norm(L*U  A) / ( N * norm(A) * EPS ), where EPS is the machine epsilon. The expression L*U  A is computed one column at a time, so A and AFAC are not modified.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  KL  KL is INTEGER The number of subdiagonals within the band of A. KL >= 0. 
[in]  KU  KU is INTEGER The number of superdiagonals within the band of A. KU >= 0. 
[in,out]  A  A is COMPLEX 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 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 CGBTRF. 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 CGBTRF 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 CGBTRF. 
[out]  WORK  WORK is COMPLEX array, dimension (2*KL+KU+1) 
[out]  RESID  RESID is REAL norm(L*U  A) / ( N * norm(A) * EPS ) 
Definition at line 126 of file cgbt01.f.
subroutine cgbt02  (  character  TRANS, 
integer  M,  
integer  N,  
integer  KL,  
integer  KU,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
real  RESID  
) 
CGBT02
CGBT02 computes the residual for a solution of a banded system of equations A*x = b or A'*x = b: RESID = norm( B  A*X ) / ( norm(A) * norm(X) * EPS). where EPS is the machine precision.
[in]  TRANS  TRANS is CHARACTER*1 Specifies the form of the system of equations: = 'N': A *x = b = 'T': A'*x = b, where A' is the transpose of A = 'C': A'*x = b, where A' is the transpose of A 
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  KL  KL is INTEGER The number of subdiagonals within the band of A. KL >= 0. 
[in]  KU  KU is INTEGER The number of superdiagonals within the band of A. KU >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B. NRHS >= 0. 
[in]  A  A is COMPLEX 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 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 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 REAL The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 139 of file cgbt02.f.
subroutine cgbt05  (  character  TRANS, 
integer  N,  
integer  KL,  
integer  KU,  
integer  NRHS,  
complex, dimension( ldab, * )  AB,  
integer  LDAB,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
CGBT05
CGBT05 tests the error bounds from iterative refinement for the computed solution to a system of equations op(A)*X = B, where A is a general band matrix of order n with kl subdiagonals and ku superdiagonals and op(A) = A or A**T, depending on TRANS. RESLTS(1) = test of the error bound = norm(X  XACT) / ( norm(X) * FERR ) A large value is returned if this ratio is not less than one. RESLTS(2) = residual from the iterative refinement routine = the maximum of BERR / ( NZ*EPS + (*) ), where (*) = NZ*UNFL / (min_i (abs(op(A))*abs(X) +abs(b))_i ) and NZ = max. number of nonzeros in any row of A, plus 1
[in]  TRANS  TRANS is CHARACTER*1 Specifies the form of the system of equations. = 'N': A * X = B (No transpose) = 'T': A**T * X = B (Transpose) = 'C': A**H * X = B (Conjugate transpose = Transpose) 
[in]  N  N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0. 
[in]  KL  KL is INTEGER The number of subdiagonals within the band of A. KL >= 0. 
[in]  KU  KU is INTEGER The number of superdiagonals within the band of A. KU >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0. 
[in]  AB  AB is COMPLEX array, dimension (LDAB,N) The original band matrix A, stored in rows 1 to KL+KU+1. The jth column of A is stored in the jth column of the array AB as follows: AB(ku+1+ij,j) = A(i,j) for max(1,jku)<=i<=min(n,j+kl). 
[in]  LDAB  LDAB is INTEGER The leading dimension of the array AB. LDAB >= KL+KU+1. 
[in]  B  B is COMPLEX 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 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 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 REAL 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 REAL 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 REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 176 of file cgbt05.f.
subroutine cgelqs  (  integer  M, 
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
integer  INFO  
) 
CGELQS
Compute a minimumnorm solution min  A*X  B  using the LQ factorization A = L*Q computed by CGELQF.
[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 array, dimension (LDA,N) Details of the LQ factorization of the original matrix A as returned by CGELQF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is COMPLEX array, dimension (M) Details of the orthogonal matrix Q. 
[in,out]  B  B is COMPLEX array, dimension (LDB,NRHS) On entry, the mbynrhs right hand side matrix B. On exit, the nbynrhs solution matrix X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= N. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK must be at least NRHS, and should be at least NRHS*NB, where NB is the block size for this environment. 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 121 of file cgelqs.f.
LOGICAL function cgennd  (  integer  M, 
integer  N,  
complex, dimension( lda, * )  A,  
integer  LDA  
) 
CGENND
CGENND tests that its argument has a real, nonnegative diagonal.
[in]  M  M is INTEGER The number of rows in A. 
[in]  N  N is INTEGER The number of columns in A. 
[in]  A  A is COMPLEX array, dimension (LDA, N) The matrix. 
[in]  LDA  LDA is INTEGER Leading dimension of A. 
Definition at line 69 of file cgennd.f.
subroutine cgeqls  (  integer  M, 
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
integer  INFO  
) 
CGEQLS
Solve the least squares problem min  A*X  B  using the QL factorization A = Q*L computed by CGEQLF.
[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 array, dimension (LDA,N) Details of the QL factorization of the original matrix A as returned by CGEQLF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is COMPLEX array, dimension (N) Details of the orthogonal matrix Q. 
[in,out]  B  B is COMPLEX array, dimension (LDB,NRHS) On entry, the mbynrhs right hand side matrix B. On exit, the nbynrhs solution matrix X, stored in rows mn+1:m. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= M. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK must be at least NRHS, and should be at least NRHS*NB, where NB is the block size for this environment. 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 122 of file cgeqls.f.
subroutine cgeqrs  (  integer  M, 
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
integer  INFO  
) 
CGEQRS
Solve the least squares problem min  A*X  B  using the QR factorization A = Q*R computed by CGEQRF.
[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 array, dimension (LDA,N) Details of the QR factorization of the original matrix A as returned by CGEQRF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is COMPLEX array, dimension (N) Details of the orthogonal matrix Q. 
[in,out]  B  B is COMPLEX array, dimension (LDB,NRHS) On entry, the mbynrhs right hand side matrix B. On exit, the nbynrhs solution matrix X. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= M. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK must be at least NRHS, and should be at least NRHS*NB, where NB is the block size for this environment. 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 121 of file cgeqrs.f.
subroutine cgerqs  (  integer  M, 
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
integer  INFO  
) 
CGERQS
Compute a minimumnorm solution min  A*X  B  using the RQ factorization A = R*Q computed by CGERQF.
[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 array, dimension (LDA,N) Details of the RQ factorization of the original matrix A as returned by CGERQF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  TAU  TAU is COMPLEX array, dimension (M) Details of the orthogonal matrix Q. 
[in,out]  B  B is COMPLEX 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 array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK must be at least NRHS, and should be at least NRHS*NB, where NB is the block size for this environment. 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 122 of file cgerqs.f.
subroutine cget01  (  integer  M, 
integer  N,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
integer, dimension( * )  IPIV,  
real, dimension( * )  RWORK,  
real  RESID  
) 
CGET01
CGET01 reconstructs a matrix A from its L*U factorization and computes the residual norm(L*U  A) / ( N * norm(A) * EPS ), where EPS is the machine epsilon.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX 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 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 CGETRF. 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 CGETRF. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESID  RESID is REAL norm(L*U  A) / ( N * norm(A) * EPS ) 
Definition at line 108 of file cget01.f.
subroutine cget02  (  character  TRANS, 
integer  M,  
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  RWORK,  
real  RESID  
) 
CGET02
CGET02 computes the residual for a solution of a system of linear equations A*x = b or A'*x = b: RESID = norm(B  A*X) / ( norm(A) * norm(X) * EPS ), where EPS is the machine epsilon.
[in]  TRANS  TRANS is CHARACTER*1 Specifies the form of the system of equations: = 'N': A *x = b = 'T': A^T*x = b, where A^T is the transpose of A = 'C': A^H*x = b, where A^H is the conjugate transpose of A 
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is COMPLEX 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 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 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 REAL array, dimension (M) 
[out]  RESID  RESID is REAL The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 133 of file cget02.f.
subroutine cget03  (  integer  N, 
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldainv, * )  AINV,  
integer  LDAINV,  
complex, dimension( ldwork, * )  WORK,  
integer  LDWORK,  
real, dimension( * )  RWORK,  
real  RCOND,  
real  RESID  
) 
CGET03
CGET03 computes the residual for a general matrix times its inverse: norm( I  AINV*A ) / ( N * norm(A) * norm(AINV) * EPS ), where EPS is the machine epsilon.
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX 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 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 array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RCOND  RCOND is REAL The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV). 
[out]  RESID  RESID is REAL norm(I  AINV*A) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 110 of file cget03.f.
subroutine cget04  (  integer  N, 
integer  NRHS,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real  RCOND,  
real  RESID  
) 
CGET04
CGET04 computes the difference between a computed solution and the true solution to a system of linear equations. RESID = ( norm(XXACT) * RCOND ) / ( norm(XACT) * EPS ), where RCOND is the reciprocal of the condition number and EPS is the machine epsilon.
[in]  N  N is INTEGER The number of rows of the matrices X and XACT. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X and XACT. NRHS >= 0. 
[in]  X  X is COMPLEX 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 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 REAL The reciprocal of the condition number of the coefficient matrix in the system of equations. 
[out]  RESID  RESID is REAL The maximum over the NRHS solution vectors of ( norm(XXACT) * RCOND ) / ( norm(XACT) * EPS ) 
Definition at line 103 of file cget04.f.
subroutine cget07  (  character  TRANS, 
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
logical  CHKFERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
CGET07
CGET07 tests the error bounds from iterative refinement for the computed solution to a system of equations op(A)*X = B, where A is a general n by n matrix and op(A) = A or A**T, depending on TRANS. RESLTS(1) = test of the error bound = norm(X  XACT) / ( norm(X) * FERR ) A large value is returned if this ratio is not less than one. RESLTS(2) = residual from the iterative refinement routine = the maximum of BERR / ( (n+1)*EPS + (*) ), where (*) = (n+1)*UNFL / (min_i (abs(op(A))*abs(X) +abs(b))_i )
[in]  TRANS  TRANS is CHARACTER*1 Specifies the form of the system of equations. = 'N': A * X = B (No transpose) = 'T': A**T * X = B (Transpose) = 'C': A**H * X = B (Conjugate transpose = Transpose) 
[in]  N  N is INTEGER The number of rows of the matrices X and XACT. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X and XACT. NRHS >= 0. 
[in]  A  A is COMPLEX 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 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 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 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 REAL array, dimension (NRHS) The estimated forward error bounds for each solution vector X. If XTRUE is the true solution, FERR bounds the magnitude of the largest entry in (X  XTRUE) divided by the magnitude of the largest entry in X. 
[in]  CHKFERR  CHKFERR is LOGICAL Set to .TRUE. to check FERR, .FALSE. not to check FERR. When the test system is illconditioned, the "true" solution in XACT may be incorrect. 
[in]  BERR  BERR is REAL 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 REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( (n+1)*EPS + (*) ) 
Definition at line 166 of file cget07.f.
subroutine cgtt01  (  integer  N, 
complex, dimension( * )  DL,  
complex, dimension( * )  D,  
complex, dimension( * )  DU,  
complex, dimension( * )  DLF,  
complex, dimension( * )  DF,  
complex, dimension( * )  DUF,  
complex, dimension( * )  DU2,  
integer, dimension( * )  IPIV,  
complex, dimension( ldwork, * )  WORK,  
integer  LDWORK,  
real, dimension( * )  RWORK,  
real  RESID  
) 
CGTT01
CGTT01 reconstructs a tridiagonal matrix A from its LU factorization and computes the residual norm(L*U  A) / ( norm(A) * EPS ), where EPS is the machine epsilon.
[in]  N  N is INTEGTER The order of the matrix A. N >= 0. 
[in]  DL  DL is COMPLEX array, dimension (N1) The (n1) subdiagonal elements of A. 
[in]  D  D is COMPLEX array, dimension (N) The diagonal elements of A. 
[in]  DU  DU is COMPLEX array, dimension (N1) The (n1) superdiagonal elements of A. 
[in]  DLF  DLF is COMPLEX array, dimension (N1) The (n1) multipliers that define the matrix L from the LU factorization of A. 
[in]  DF  DF is COMPLEX array, dimension (N) The n diagonal elements of the upper triangular matrix U from the LU factorization of A. 
[in]  DUF  DUF is COMPLEX array, dimension (N1) The (n1) elements of the first superdiagonal of U. 
[in]  DU2  DU2 is COMPLEX array, dimension (N2) The (n2) elements of the second superdiagonal of U. 
[in]  IPIV  IPIV is INTEGER array, dimension (N) The pivot indices; for 1 <= i <= n, row i of the matrix was interchanged with row IPIV(i). IPIV(i) will always be either i or i+1; IPIV(i) = i indicates a row interchange was not required. 
[out]  WORK  WORK is COMPLEX array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL The scaled residual: norm(L*U  A) / (norm(A) * EPS) 
Definition at line 134 of file cgtt01.f.
subroutine cgtt02  (  character  TRANS, 
integer  N,  
integer  NRHS,  
complex, dimension( * )  DL,  
complex, dimension( * )  D,  
complex, dimension( * )  DU,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
real  RESID  
) 
CGTT02
CGTT02 computes the residual for the solution to a tridiagonal system of equations: RESID = norm(B  op(A)*X) / (norm(A) * norm(X) * EPS), where EPS is the machine epsilon.
[in]  TRANS  TRANS is CHARACTER Specifies the form of the residual. = 'N': B  A * X (No transpose) = 'T': B  A**T * X (Transpose) = 'C': B  A**H * X (Conjugate transpose) 
[in]  N  N is INTEGTER The order of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0. 
[in]  DL  DL is COMPLEX array, dimension (N1) The (n1) subdiagonal elements of A. 
[in]  D  D is COMPLEX array, dimension (N) The diagonal elements of A. 
[in]  DU  DU is COMPLEX array, dimension (N1) The (n1) superdiagonal elements of A. 
[in]  X  X is COMPLEX 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 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 REAL norm(B  op(A)*X) / (norm(A) * norm(X) * EPS) 
Definition at line 124 of file cgtt02.f.
subroutine cgtt05  (  character  TRANS, 
integer  N,  
integer  NRHS,  
complex, dimension( * )  DL,  
complex, dimension( * )  D,  
complex, dimension( * )  DU,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
CGTT05
CGTT05 tests the error bounds from iterative refinement for the computed solution to a system of equations A*X = B, where A is a general tridiagonal matrix of order n and op(A) = A or A**T, depending on TRANS. RESLTS(1) = test of the error bound = norm(X  XACT) / ( norm(X) * FERR ) A large value is returned if this ratio is not less than one. RESLTS(2) = residual from the iterative refinement routine = the maximum of BERR / ( NZ*EPS + (*) ), where (*) = NZ*UNFL / (min_i (abs(op(A))*abs(X) +abs(b))_i ) and NZ = max. number of nonzeros in any row of A, plus 1
[in]  TRANS  TRANS is CHARACTER*1 Specifies the form of the system of equations. = 'N': A * X = B (No transpose) = 'T': A**T * X = B (Transpose) = 'C': A**H * X = B (Conjugate transpose = Transpose) 
[in]  N  N is INTEGER The number of rows of the matrices X and XACT. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X and XACT. NRHS >= 0. 
[in]  DL  DL is COMPLEX array, dimension (N1) The (n1) subdiagonal elements of A. 
[in]  D  D is COMPLEX array, dimension (N) The diagonal elements of A. 
[in]  DU  DU is COMPLEX array, dimension (N1) The (n1) superdiagonal elements of A. 
[in]  B  B is COMPLEX 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 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 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 REAL 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 REAL 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 REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 165 of file cgtt05.f.
subroutine chet01  (  character  UPLO, 
integer  N,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
integer, dimension( * )  IPIV,  
complex, dimension( ldc, * )  C,  
integer  LDC,  
real, dimension( * )  RWORK,  
real  RESID  
) 
CHET01
CHET01 reconstructs a Hermitian indefinite matrix A from its block L*D*L' or U*D*U' factorization and computes the residual norm( C  A ) / ( N * norm(A) * EPS ), where C is the reconstructed matrix, EPS is the machine epsilon, L' is the conjugate transpose of L, and U' is the conjugate transpose of U.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX 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 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 CHETRF. 
[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 CHETRF. 
[out]  C  C is COMPLEX array, dimension (LDC,N) 
[in]  LDC  LDC is INTEGER The leading dimension of the array C. LDC >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL If UPLO = 'L', norm(L*D*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U*D*U'  A) / ( N * norm(A) * EPS ) 
Definition at line 126 of file chet01.f.
subroutine chkxer  (  character*(*)  SRNAMT, 
integer  INFOT,  
integer  NOUT,  
logical  LERR,  
logical  OK  
) 
subroutine chpt01  (  character  UPLO, 
integer  N,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
integer, dimension( * )  IPIV,  
complex, dimension( ldc, * )  C,  
integer  LDC,  
real, dimension( * )  RWORK,  
real  RESID  
) 
CHPT01
CHPT01 reconstructs a Hermitian indefinite packed matrix A from its block L*D*L' or U*D*U' factorization and computes the residual norm( C  A ) / ( N * norm(A) * EPS ), where C is the reconstructed matrix, EPS is the machine epsilon, L' is the conjugate transpose of L, and U' is the conjugate transpose of U.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX array, dimension (N*(N+1)/2) The original Hermitian matrix A, stored as a packed triangular matrix. 
[in]  AFAC  AFAC is COMPLEX 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 CHPTRF. 
[in]  IPIV  IPIV is INTEGER array, dimension (N) The pivot indices from CHPTRF. 
[out]  C  C is COMPLEX array, dimension (LDC,N) 
[in]  LDC  LDC is INTEGER The leading dimension of the array C. LDC >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL If UPLO = 'L', norm(L*D*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U*D*U'  A) / ( N * norm(A) * EPS ) 
Definition at line 114 of file chpt01.f.
subroutine clahilb  (  integer  N, 
integer  NRHS,  
complex, dimension(lda,n)  A,  
integer  LDA,  
complex, dimension(ldx, nrhs)  X,  
integer  LDX,  
complex, dimension(ldb, nrhs)  B,  
integer  LDB,  
real, dimension(n)  WORK,  
integer  INFO,  
character*3  PATH  
) 
CLAHILB
CLAHILB generates an N by N scaled Hilbert matrix in A along with NRHS righthand sides in B and solutions in X such that A*X=B. The Hilbert matrix is scaled by M = LCM(1, 2, ..., 2*N1) so that all entries are integers. The righthand sides are the first NRHS columns of M * the identity matrix, and the solutions are the first NRHS columns of the inverse Hilbert matrix. The condition number of the Hilbert matrix grows exponentially with its size, roughly as O(e ** (3.5*N)). Additionally, the inverse Hilbert matrices beyond a relatively small dimension cannot be generated exactly without extra precision. Precision is exhausted when the largest entry in the inverse Hilbert matrix is greater than 2 to the power of the number of bits in the fraction of the data type used plus one, which is 24 for single precision. In single, the generated solution is exact for N <= 6 and has small componentwise error for 7 <= N <= 11.
[in]  N  N is INTEGER The dimension of the matrix A. 
[in]  NRHS  NRHS is NRHS The requested number of righthand sides. 
[out]  A  A is COMPLEX array, dimension (LDA, N) The generated scaled Hilbert matrix. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= N. 
[out]  X  X is COMPLEX array, dimension (LDX, NRHS) The generated exact solutions. Currently, the first NRHS columns of the inverse Hilbert matrix. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. LDX >= N. 
[out]  B  B is REAL array, dimension (LDB, NRHS) The generated righthand sides. Currently, the first NRHS columns of LCM(1, 2, ..., 2*N1) * the identity matrix. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= N. 
[out]  WORK  WORK is REAL array, dimension (N) 
[out]  INFO  INFO is INTEGER = 0: successful exit = 1: N is too large; the data is still generated but may not be not exact. < 0: if INFO = i, the ith argument had an illegal value 
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name. 
Definition at line 134 of file clahilb.f.
subroutine claipd  (  integer  N, 
complex, dimension( * )  A,  
integer  INDA,  
integer  VINDA  
) 
CLAIPD
CLAIPD sets the imaginary part of the diagonal elements of a complex matrix A to a large value. This is used to test LAPACK routines for complex Hermitian matrices, which are not supposed to access or use the imaginary parts of the diagonals.
[in]  N  N is INTEGER The number of diagonal elements of A. 
[in,out]  A  A is COMPLEX array, dimension (1+(N1)*INDA+(N2)*VINDA) On entry, the complex (Hermitian) matrix A. On exit, the imaginary parts of the diagonal elements are set to BIGNUM = EPS / SAFMIN, where EPS is the machine epsilon and SAFMIN is the safe minimum. 
[in]  INDA  INDA is INTEGER The increment between A(1) and the next diagonal element of A. Typical values are = LDA+1: square matrices with leading dimension LDA = 2: packed upper triangular matrix, starting at A(1,1) = N: packed lower triangular matrix, starting at A(1,1) 
[in]  VINDA  VINDA is INTEGER The change in the diagonal increment between columns of A. Typical values are = 0: no change, the row and column increments in A are fixed = 1: packed upper triangular matrix = 1: packed lower triangular matrix 
Definition at line 84 of file claipd.f.
subroutine claptm  (  character  UPLO, 
integer  N,  
integer  NRHS,  
real  ALPHA,  
real, dimension( * )  D,  
complex, dimension( * )  E,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
real  BETA,  
complex, dimension( ldb, * )  B,  
integer  LDB  
) 
CLAPTM
CLAPTM multiplies an N by NRHS matrix X by a Hermitian tridiagonal matrix A and stores the result in a matrix B. The operation has the form B := alpha * A * X + beta * B where alpha may be either 1. or 1. and beta may be 0., 1., or 1.
[in]  UPLO  UPLO is CHARACTER Specifies whether the superdiagonal or the subdiagonal of the tridiagonal matrix A is stored. = 'U': Upper, E is the superdiagonal of A. = 'L': Lower, E is the subdiagonal of A. 
[in]  N  N is INTEGER The order of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices X and B. 
[in]  ALPHA  ALPHA is REAL The scalar alpha. ALPHA must be 1. or 1.; otherwise, it is assumed to be 0. 
[in]  D  D is REAL array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is COMPLEX array, dimension (N1) The (n1) subdiagonal or superdiagonal elements of A. 
[in]  X  X is COMPLEX 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 REAL The scalar beta. BETA must be 0., 1., or 1.; otherwise, it is assumed to be 1. 
[in,out]  B  B is COMPLEX array, dimension (LDB,NRHS) On entry, the N by NRHS matrix B. On exit, B is overwritten by the matrix expression B := alpha * A * X + beta * B. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(N,1). 
Definition at line 129 of file claptm.f.
subroutine clarhs  (  character*3  PATH, 
character  XTYPE,  
character  UPLO,  
character  TRANS,  
integer  M,  
integer  N,  
integer  KL,  
integer  KU,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
integer, dimension( 4 )  ISEED,  
integer  INFO  
) 
CLARHS
CLARHS chooses a set of NRHS random solution vectors and sets up the right hand sides for the linear system op( A ) * X = B, where op( A ) may be A, A**T (transpose of A), or A**H (conjugate transpose of A).
[in]  PATH  PATH is CHARACTER*3 The type of the complex matrix A. PATH may be given in any combination of upper and lower case. Valid paths include xGE: General m x n matrix xGB: General banded matrix xPO: Hermitian positive definite, 2D storage xPP: Hermitian positive definite packed xPB: Hermitian positive definite banded xHE: Hermitian indefinite, 2D storage xHP: Hermitian indefinite packed xHB: Hermitian indefinite banded xSY: Symmetric indefinite, 2D storage xSP: Symmetric indefinite packed xSB: Symmetric indefinite banded xTR: Triangular xTP: Triangular packed xTB: Triangular banded xQR: General m x n matrix xLQ: General m x n matrix xQL: General m x n matrix xRQ: General m x n matrix where the leading character indicates the precision. 
[in]  XTYPE  XTYPE is CHARACTER*1 Specifies how the exact solution X will be determined: = 'N': New solution; generate a random X. = 'C': Computed; use value of X on entry. 
[in]  UPLO  UPLO is CHARACTER*1 Used only if A is symmetric or triangular; specifies whether the upper or lower triangular part of the matrix A is stored. = 'U': Upper triangular = 'L': Lower triangular 
[in]  TRANS  TRANS is CHARACTER*1 Used only if A is nonsymmetric; specifies the operation applied to the matrix A. = 'N': B := A * X = 'T': B := A**T * X = 'C': B := A**H * X 
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  KL  KL is INTEGER Used only if A is a band matrix; specifies the number of subdiagonals of A if A is a general band matrix or if A is symmetric or triangular and UPLO = 'L'; specifies the number of superdiagonals of A if A is symmetric or triangular and UPLO = 'U'. 0 <= KL <= M1. 
[in]  KU  KU is INTEGER Used only if A is a general band matrix or if A is triangular. If PATH = xGB, specifies the number of superdiagonals of A, and 0 <= KU <= N1. If PATH = xTR, xTP, or xTB, specifies whether or not the matrix has unit diagonal: = 1: matrix has nonunit diagonal (default) = 2: matrix has unit diagonal 
[in]  NRHS  NRHS is INTEGER The number of right hand side vectors in the system A*X = B. 
[in]  A  A is COMPLEX 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 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 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 CLATMS). Modified on exit. 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = k, the kth argument had an illegal value 
Definition at line 209 of file clarhs.f.
subroutine clatb4  (  character*3  PATH, 
integer  IMAT,  
integer  M,  
integer  N,  
character  TYPE,  
integer  KL,  
integer  KU,  
real  ANORM,  
integer  MODE,  
real  CNDNUM,  
character  DIST  
) 
CLATB4
CLATB4 sets parameters for the matrix generator based on the type of matrix to be generated.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name. 
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  M  M is INTEGER The number of rows in the matrix to be generated. 
[in]  N  N is INTEGER The number of columns in the matrix to be generated. 
[out]  TYPE  TYPE is CHARACTER*1 The type of the matrix to be generated: = 'S': symmetric matrix = 'P': symmetric positive (semi)definite matrix = 'N': nonsymmetric matrix 
[out]  KL  KL is INTEGER The lower band width of the matrix to be generated. 
[out]  KU  KU is INTEGER The upper band width of the matrix to be generated. 
[out]  ANORM  ANORM is REAL 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 REAL The desired condition number. 
[out]  DIST  DIST is CHARACTER*1 The type of distribution to be used by the random number generator. 
Definition at line 120 of file clatb4.f.
subroutine clatb5  (  character*3  PATH, 
integer  IMAT,  
integer  N,  
character  TYPE,  
integer  KL,  
integer  KU,  
real  ANORM,  
integer  MODE,  
real  CNDNUM,  
character  DIST  
) 
CLATB5
CLATB5 sets parameters for the matrix generator based on the type of matrix to be generated.
[in]  PATH  PATH is CHARACTER*3 The LAPACK path name. 
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  N  N is INTEGER The number of rows and columns in the matrix to be generated. 
[out]  TYPE  TYPE is CHARACTER*1 The type of the matrix to be generated: = 'S': symmetric matrix = 'P': symmetric positive (semi)definite matrix = 'N': nonsymmetric matrix 
[out]  KL  KL is INTEGER The lower band width of the matrix to be generated. 
[out]  KU  KU is INTEGER The upper band width of the matrix to be generated. 
[out]  ANORM  ANORM is REAL 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 REAL The desired condition number. 
[out]  DIST  DIST is CHARACTER*1 The type of distribution to be used by the random number generator. 
Definition at line 114 of file clatb5.f.
subroutine clatsp  (  character  UPLO, 
integer  N,  
complex, dimension( * )  X,  
integer, dimension( * )  ISEED  
) 
CLATSP
CLATSP generates a special test matrix for the complex symmetric (indefinite) factorization for packed matrices. The pivot blocks of the generated matrix will be in the following order: 2x2 pivot block, non diagonalizable 1x1 pivot block 2x2 pivot block, diagonalizable (cycle repeats) A row interchange is required for each nondiagonalizable 2x2 block.
[in]  UPLO  UPLO is CHARACTER Specifies whether the generated matrix is to be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The dimension of the matrix to be generated. 
[out]  X  X is COMPLEX array, dimension (N*(N+1)/2) The generated matrix in packed storage format. The matrix consists of 3x3 and 2x2 diagonal blocks which result in the pivot sequence given above. The matrix outside these diagonal blocks is zero. 
[in,out]  ISEED  ISEED is INTEGER array, dimension (4) On entry, the seed for the random number generator. The last of the four integers must be odd. (modified on exit) 
Definition at line 85 of file clatsp.f.
subroutine clatsy  (  character  UPLO, 
integer  N,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
integer, dimension( * )  ISEED  
) 
CLATSY
CLATSY generates a special test matrix for the complex symmetric (indefinite) factorization. The pivot blocks of the generated matrix will be in the following order: 2x2 pivot block, non diagonalizable 1x1 pivot block 2x2 pivot block, diagonalizable (cycle repeats) A row interchange is required for each nondiagonalizable 2x2 block.
[in]  UPLO  UPLO is CHARACTER Specifies whether the generated matrix is to be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The dimension of the matrix to be generated. 
[out]  X  X is COMPLEX array, dimension (LDX,N) The generated matrix, consisting of 3x3 and 2x2 diagonal blocks which result in the pivot sequence given above. The matrix outside of these diagonal blocks is zero. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. 
[in,out]  ISEED  ISEED is INTEGER array, dimension (4) On entry, the seed for the random number generator. The last of the four integers must be odd. (modified on exit) 
Definition at line 90 of file clatsy.f.
subroutine clattb  (  integer  IMAT, 
character  UPLO,  
character  TRANS,  
character  DIAG,  
integer, dimension( 4 )  ISEED,  
integer  N,  
integer  KD,  
complex, dimension( ldab, * )  AB,  
integer  LDAB,  
complex, dimension( * )  B,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  INFO  
) 
CLATTB
CLATTB generates a triangular test matrix in 2dimensional storage. IMAT and UPLO uniquely specify the properties of the test matrix, which is returned in the array A.
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the matrix A will be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  TRANS  TRANS is CHARACTER*1 Specifies whether the matrix or its transpose will be used. = 'N': No transpose = 'T': Transpose = 'C': Conjugate transpose (= transpose) 
[out]  DIAG  DIAG is CHARACTER*1 Specifies whether or not the matrix A is unit triangular. = 'N': Nonunit triangular = 'U': Unit triangular 
[in,out]  ISEED  ISEED is INTEGER array, dimension (4) The seed vector for the random number generator (used in CLATMS). 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 array, dimension (LDAB,N) The upper or lower triangular banded matrix A, stored in the first KD+1 rows of AB. Let j be a column of A, 1<=j<=n. If UPLO = 'U', AB(kd+1+ij,j) = A(i,j) for max(1,jkd)<=i<=j. If UPLO = 'L', AB(1+ij,j) = A(i,j) for j<=i<=min(n,j+kd). 
[in]  LDAB  LDAB is INTEGER The leading dimension of the array AB. LDAB >= KD+1. 
[out]  B  B is COMPLEX array, dimension (N) 
[out]  WORK  WORK is COMPLEX array, dimension (2*N) 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 141 of file clattb.f.
subroutine clattp  (  integer  IMAT, 
character  UPLO,  
character  TRANS,  
character  DIAG,  
integer, dimension( 4 )  ISEED,  
integer  N,  
complex, dimension( * )  AP,  
complex, dimension( * )  B,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  INFO  
) 
CLATTP
CLATTP generates a triangular test matrix in packed storage. IMAT and UPLO uniquely specify the properties of the test matrix, which is returned in the array AP.
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the matrix A will be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  TRANS  TRANS is CHARACTER*1 Specifies whether the matrix or its transpose will be used. = 'N': No transpose = 'T': Transpose = 'C': Conjugate transpose 
[out]  DIAG  DIAG is CHARACTER*1 Specifies whether or not the matrix A is unit triangular. = 'N': Nonunit triangular = 'U': Unit triangular 
[in,out]  ISEED  ISEED is INTEGER array, dimension (4) The seed vector for the random number generator (used in CLATMS). Modified on exit. 
[in]  N  N is INTEGER The order of the matrix to be generated. 
[out]  AP  AP is COMPLEX array, dimension (N*(N+1)/2) The upper or lower triangular matrix A, packed columnwise in a linear array. The jth column of A is stored in the array AP as follows: if UPLO = 'U', AP((j1)*j/2 + i) = A(i,j) for 1<=i<=j; if UPLO = 'L', AP((j1)*(nj) + j*(j+1)/2 + ij) = A(i,j) for j<=i<=n. 
[out]  B  B is COMPLEX array, dimension (N) The right hand side vector, if IMAT > 10. 
[out]  WORK  WORK is COMPLEX array, dimension (2*N) 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 131 of file clattp.f.
subroutine clattr  (  integer  IMAT, 
character  UPLO,  
character  TRANS,  
character  DIAG,  
integer, dimension( 4 )  ISEED,  
integer  N,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( * )  B,  
complex, dimension( * )  WORK,  
real, dimension( * )  RWORK,  
integer  INFO  
) 
CLATTR
CLATTR generates a triangular test matrix in 2dimensional storage. IMAT and UPLO uniquely specify the properties of the test matrix, which is returned in the array A.
[in]  IMAT  IMAT is INTEGER An integer key describing which matrix to generate for this path. 
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the matrix A will be upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  TRANS  TRANS is CHARACTER*1 Specifies whether the matrix or its transpose will be used. = 'N': No transpose = 'T': Transpose = 'C': Conjugate transpose 
[out]  DIAG  DIAG is CHARACTER*1 Specifies whether or not the matrix A is unit triangular. = 'N': Nonunit triangular = 'U': Unit triangular 
[in,out]  ISEED  ISEED is INTEGER array, dimension (4) The seed vector for the random number generator (used in CLATMS). Modified on exit. 
[in]  N  N is INTEGER The order of the matrix to be generated. 
[out]  A  A is COMPLEX 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 array, dimension (N) The right hand side vector, if IMAT > 10. 
[out]  WORK  WORK is COMPLEX array, dimension (2*N) 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = i, the ith argument had an illegal value 
Definition at line 138 of file clattr.f.
subroutine clavhe  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
integer, dimension( * )  IPIV,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
integer  INFO  
) 
CLAVHE
CLAVHE performs one of the matrixvector operations x := A*x or x := A^H*x, where x is an N element vector and A is one of the factors from the symmetric factorization computed by CHETRF. CHETRF produces a factorization of the form U * D * U^H or L * D * L^H, where U (or L) is a product of permutation and unit upper (lower) triangular matrices, U^H (or L^H) is the conjugate transpose of U (or L), and D is Hermitian and block diagonal with 1 x 1 and 2 x 2 diagonal blocks. The multipliers for the transformations and the upper or lower triangular parts of the diagonal blocks are stored in the leading upper or lower triangle of the 2D array A. If TRANS = 'N' or 'n', CLAVHE multiplies either by U or U * D (or L or L * D). If TRANS = 'C' or 'c', CLAVHE multiplies either by U^H or D * U^H (or L^H or D * L^H ).
UPLO  CHARACTER*1 On entry, UPLO specifies whether the triangular matrix stored in A is upper or lower triangular. UPLO = 'U' or 'u' The matrix is upper triangular. UPLO = 'L' or 'l' The matrix is lower triangular. Unchanged on exit. TRANS  CHARACTER*1 On entry, TRANS specifies the operation to be performed as follows: TRANS = 'N' or 'n' x := A*x. TRANS = 'C' or 'c' x := A^H*x. Unchanged on exit. DIAG  CHARACTER*1 On entry, DIAG specifies whether the diagonal blocks are assumed to be unit matrices: DIAG = 'U' or 'u' Diagonal blocks are unit matrices. DIAG = 'N' or 'n' Diagonal blocks are nonunit. Unchanged on exit. N  INTEGER On entry, N specifies the order of the matrix A. N must be at least zero. Unchanged on exit. NRHS  INTEGER On entry, NRHS specifies the number of right hand sides, i.e., the number of vectors x to be multiplied by A. NRHS must be at least zero. Unchanged on exit. A  COMPLEX array, dimension( LDA, N ) On entry, A contains a block diagonal matrix and the multipliers of the transformations used to obtain it, stored as a 2D triangular matrix. Unchanged on exit. LDA  INTEGER On entry, LDA specifies the first dimension of A as declared in the calling ( sub ) program. LDA must be at least max( 1, N ). Unchanged on exit. IPIV  INTEGER array, dimension( N ) On entry, IPIV contains the vector of pivot indices as determined by CSYTRF or CHETRF. If IPIV( K ) = K, no interchange was done. If IPIV( K ) <> K but IPIV( K ) > 0, then row K was inter changed with row IPIV( K ) and a 1 x 1 pivot block was used. If IPIV( K ) < 0 and UPLO = 'U', then row K1 was exchanged with row  IPIV( K )  and a 2 x 2 pivot block was used. If IPIV( K ) < 0 and UPLO = 'L', then row K+1 was exchanged with row  IPIV( K )  and a 2 x 2 pivot block was used. B  COMPLEX array, dimension( LDB, NRHS ) On entry, B contains NRHS vectors of length N. On exit, B is overwritten with the product A * B. LDB  INTEGER On entry, LDB contains the leading dimension of B as declared in the calling program. LDB must be at least max( 1, N ). Unchanged on exit. INFO  INTEGER INFO is the error flag. On exit, a value of 0 indicates a successful exit. A negative value, say K, indicates that the Kth argument has an illegal value.
Definition at line 138 of file clavhe.f.
subroutine clavhp  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  NRHS,  
complex, dimension( * )  A,  
integer, dimension( * )  IPIV,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
integer  INFO  
) 
CLAVHP
CLAVHP performs one of the matrixvector operations x := A*x or x := A^H*x, where x is an N element vector and A is one of the factors from the symmetric factorization computed by CHPTRF. CHPTRF 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', CLAVHP multiplies either by U or U * D (or L or L * D). If TRANS = 'C' or 'c', CLAVHP multiplies either by U^H or D * U^H (or L^H or D * L^H ).
UPLO  CHARACTER*1 On entry, UPLO specifies whether the triangular matrix stored in A is upper or lower triangular. UPLO = 'U' or 'u' The matrix is upper triangular. UPLO = 'L' or 'l' The matrix is lower triangular. Unchanged on exit. TRANS  CHARACTER*1 On entry, TRANS specifies the operation to be performed as follows: TRANS = 'N' or 'n' x := A*x. TRANS = 'C' or 'c' x := A^H*x. Unchanged on exit. DIAG  CHARACTER*1 On entry, DIAG specifies whether the diagonal blocks are assumed to be unit matrices, as follows: DIAG = 'U' or 'u' Diagonal blocks are unit matrices. DIAG = 'N' or 'n' Diagonal blocks are nonunit. Unchanged on exit. N  INTEGER On entry, N specifies the order of the matrix A. N must be at least zero. Unchanged on exit. NRHS  INTEGER On entry, NRHS specifies the number of right hand sides, i.e., the number of vectors x to be multiplied by A. NRHS must be at least zero. Unchanged on exit. A  COMPLEX 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 CSPTRF or CHPTRF. If IPIV( K ) = K, no interchange was done. If IPIV( K ) <> K but IPIV( K ) > 0, then row K was inter changed with row IPIV( K ) and a 1 x 1 pivot block was used. If IPIV( K ) < 0 and UPLO = 'U', then row K1 was exchanged with row  IPIV( K )  and a 2 x 2 pivot block was used. If IPIV( K ) < 0 and UPLO = 'L', then row K+1 was exchanged with row  IPIV( K )  and a 2 x 2 pivot block was used. B  COMPLEX array, dimension( LDB, NRHS ) On entry, B contains NRHS vectors of length N. On exit, B is overwritten with the product A * B. LDB  INTEGER On entry, LDB contains the leading dimension of B as declared in the calling program. LDB must be at least max( 1, N ). Unchanged on exit. INFO  INTEGER INFO is the error flag. On exit, a value of 0 indicates a successful exit. A negative value, say K, indicates that the Kth argument has an illegal value.
Definition at line 131 of file clavhp.f.
subroutine clavsp  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  NRHS,  
complex, dimension( * )  A,  
integer, dimension( * )  IPIV,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
integer  INFO  
) 
CLAVSP
CLAVSP performs one of the matrixvector operations x := A*x or x := A^T*x, where x is an N element vector and A is one of the factors from the symmetric factorization computed by CSPTRF. CSPTRF 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', CLAVSP multiplies either by U or U * D (or L or L * D). If TRANS = 'C' or 'c', CLAVSP multiplies either by U^T or D * U^T (or L^T or D * L^T ).
UPLO  CHARACTER*1 On entry, UPLO specifies whether the triangular matrix stored in A is upper or lower triangular. UPLO = 'U' or 'u' The matrix is upper triangular. UPLO = 'L' or 'l' The matrix is lower triangular. Unchanged on exit. TRANS  CHARACTER*1 On entry, TRANS specifies the operation to be performed as follows: TRANS = 'N' or 'n' x := A*x. TRANS = 'T' or 't' x := A^T*x. Unchanged on exit. DIAG  CHARACTER*1 On entry, DIAG specifies whether the diagonal blocks are assumed to be unit matrices, as follows: DIAG = 'U' or 'u' Diagonal blocks are unit matrices. DIAG = 'N' or 'n' Diagonal blocks are nonunit. Unchanged on exit. N  INTEGER On entry, N specifies the order of the matrix A. N must be at least zero. Unchanged on exit. NRHS  INTEGER On entry, NRHS specifies the number of right hand sides, i.e., the number of vectors x to be multiplied by A. NRHS must be at least zero. Unchanged on exit. A  COMPLEX 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 CSPTRF. If IPIV( K ) = K, no interchange was done. If IPIV( K ) <> K but IPIV( K ) > 0, then row K was inter changed with row IPIV( K ) and a 1 x 1 pivot block was used. If IPIV( K ) < 0 and UPLO = 'U', then row K1 was exchanged with row  IPIV( K )  and a 2 x 2 pivot block was used. If IPIV( K ) < 0 and UPLO = 'L', then row K+1 was exchanged with row  IPIV( K )  and a 2 x 2 pivot block was used. B  COMPLEX array, dimension( LDB, NRHS ) On entry, B contains NRHS vectors of length N. On exit, B is overwritten with the product A * B. LDB  INTEGER On entry, LDB contains the leading dimension of B as declared in the calling program. LDB must be at least max( 1, N ). Unchanged on exit. INFO  INTEGER INFO is the error flag. On exit, a value of 0 indicates a successful exit. A negative value, say K, indicates that the Kth argument has an illegal value.
Definition at line 131 of file clavsp.f.
subroutine clavsy  (  character  UPLO, 
character  TRANS,  
character  DIAG,  
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
integer, dimension( * )  IPIV,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
integer  INFO  
) 
CLAVSY
CLAVSY performs one of the matrixvector operations x := A*x or x := A'*x, where x is an N element vector and A is one of the factors from the block U*D*U' or L*D*L' factorization computed by CSYTRF. If TRANS = 'N', multiplies by U or U * D (or L or L * D) If TRANS = 'T', multiplies by U' or D * U' (or L' or D * L')
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the factor stored in A is upper or lower triangular. = 'U': Upper triangular = 'L': Lower triangular 
[in]  TRANS  TRANS is CHARACTER*1 Specifies the operation to be performed: = 'N': x := A*x = 'T': x := A'*x 
[in]  DIAG  DIAG is CHARACTER*1 Specifies whether or not the diagonal blocks are unit matrices. If the diagonal blocks are assumed to be unit, then A = U or A = L, otherwise A = U*D or A = L*D. = 'U': Diagonal blocks are assumed to be unit matrices. = 'N': Diagonal blocks are assumed to be nonunit matrices. 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of vectors x to be multiplied by A. NRHS >= 0. 
[in]  A  A is COMPLEX array, dimension (LDA,N) The block diagonal matrix D and the multipliers used to obtain the factor U or L as computed by CSYTRF. 
[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 CSYTRF or CHETRF. If UPLO = 'U': If IPIV(k) > 0, then rows and columns k and IPIV(k) were interchanged and D(k,k) is a 1by1 diagonal block. (If IPIV( k ) = k, no interchange was done). If IPIV(k) = IPIV(k1) < 0, then rows and columns k1 and IPIV(k) were interchanged, D(k1:k,k1:k) is a 2by2 diagonal block. If UPLO = 'L': If IPIV(k) > 0, then rows and columns k and IPIV(k) were interchanged and D(k,k) is a 1by1 diagonal block. (If IPIV( k ) = k, no interchange was done). If IPIV(k) = IPIV(k+1) < 0, then rows and columns k+1 and IPIV(k) were interchanged, D(k:k+1,k:k+1) is a 2by2 diagonal block. 
[in,out]  B  B is COMPLEX array, dimension (LDB,NRHS) On entry, B contains NRHS vectors of length N. On exit, B is overwritten with the product A * B. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. LDB >= max(1,N). 
[out]  INFO  INFO is INTEGER = 0: successful exit < 0: if INFO = k, the kth argument had an illegal value 
Definition at line 152 of file clavsy.f.
subroutine clqt01  (  integer  M, 
integer  N,  
complex, dimension( lda, * )  A,  
complex, dimension( lda, * )  AF,  
complex, dimension( lda, * )  Q,  
complex, dimension( lda, * )  L,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
CLQT01
CLQT01 tests CGELQF, which computes the LQ factorization of an mbyn matrix A, and partially tests CUNGLQ which forms the nbyn orthogonal matrix Q. CLQT01 compares L with A*Q', and checks that Q is orthogonal.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is COMPLEX array, dimension (LDA,N) Details of the LQ factorization of A, as returned by CGELQF. See CGELQF for further details. 
[out]  Q  Q is COMPLEX array, dimension (LDA,N) The nbyn orthogonal matrix Q. 
[out]  L  L is COMPLEX 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 array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by CGELQF. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (max(M,N)) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( L  A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I  Q*Q' ) / ( N * EPS ) 
Definition at line 126 of file clqt01.f.
subroutine clqt02  (  integer  M, 
integer  N,  
integer  K,  
complex, dimension( lda, * )  A,  
complex, dimension( lda, * )  AF,  
complex, dimension( lda, * )  Q,  
complex, dimension( lda, * )  L,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
CLQT02
CLQT02 tests CUNGLQ, which generates an mbyn matrix Q with orthonornmal rows that is defined as the product of k elementary reflectors. Given the LQ factorization of an mbyn matrix A, CLQT02 generates the orthogonal matrix Q defined by the factorization of the first k rows of A; it compares L(1:k,1:m) with A(1:k,1:n)*Q(1:m,1:n)', and checks that the rows of Q are orthonormal.
[in]  M  M is INTEGER The number of rows of the matrix Q to be generated. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix Q to be generated. N >= M >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the matrix Q. M >= K >= 0. 
[in]  A  A is COMPLEX array, dimension (LDA,N) The mbyn matrix A which was factorized by CLQT01. 
[in]  AF  AF is COMPLEX array, dimension (LDA,N) Details of the LQ factorization of A, as returned by CGELQF. See CGELQF for further details. 
[out]  Q  Q is COMPLEX array, dimension (LDA,N) 
[out]  L  L is COMPLEX 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 array, dimension (M) The scalar factors of the elementary reflectors corresponding to the LQ factorization in AF. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( L  A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I  Q*Q' ) / ( N * EPS ) 
Definition at line 135 of file clqt02.f.
subroutine clqt03  (  integer  M, 
integer  N,  
integer  K,  
complex, dimension( lda, * )  AF,  
complex, dimension( lda, * )  C,  
complex, dimension( lda, * )  CC,  
complex, dimension( lda, * )  Q,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
CLQT03
CLQT03 tests CUNMLQ, which computes Q*C, Q'*C, C*Q or C*Q'. CLQT03 compares the results of a call to CUNMLQ with the results of forming Q explicitly by a call to CUNGLQ and then performing matrix multiplication by a call to CGEMM.
[in]  M  M is INTEGER The number of rows or columns of the matrix C; C is nbym if Q is applied from the left, or mbyn if Q is applied from the right. M >= 0. 
[in]  N  N is INTEGER The order of the orthogonal matrix Q. N >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the orthogonal matrix Q. N >= K >= 0. 
[in]  AF  AF is COMPLEX array, dimension (LDA,N) Details of the LQ factorization of an mbyn matrix, as returned by CGELQF. See CGELQF for further details. 
[out]  C  C is COMPLEX array, dimension (LDA,N) 
[out]  CC  CC is COMPLEX array, dimension (LDA,N) 
[out]  Q  Q is COMPLEX 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 array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the LQ factorization in AF. 
[out]  WORK  WORK is COMPLEX 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 REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an nbyn orthogonal matrix Q. RESULT(1) = norm( Q*C  Q*C ) / ( N * norm(C) * EPS ) RESULT(2) = norm( C*Q  C*Q ) / ( N * norm(C) * EPS ) RESULT(3) = norm( Q'*C  Q'*C )/ ( N * norm(C) * EPS ) RESULT(4) = norm( C*Q'  C*Q' )/ ( N * norm(C) * EPS ) 
Definition at line 136 of file clqt03.f.
subroutine cpbt01  (  character  UPLO, 
integer  N,  
integer  KD,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
real, dimension( * )  RWORK,  
real  RESID  
) 
CPBT01
CPBT01 reconstructs a Hermitian positive definite band matrix A from its L*L' or U'*U factorization and computes the residual norm( L*L'  A ) / ( N * norm(A) * EPS ) or norm( U'*U  A ) / ( N * norm(A) * EPS ), where EPS is the machine epsilon, L' is the conjugate transpose of L, and U' is the conjugate transpose of U.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  KD  KD is INTEGER The number of superdiagonals of the matrix A if UPLO = 'U', or the number of subdiagonals if UPLO = 'L'. KD >= 0. 
[in]  A  A is COMPLEX 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 CPBTRF 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 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 CPBTRF. 
[in]  LDAFAC  LDAFAC is INTEGER The leading dimension of the array AFAC. LDAFAC >= max(1,KD+1). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL If UPLO = 'L', norm(L*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U  A) / ( N * norm(A) * EPS ) 
Definition at line 120 of file cpbt01.f.
subroutine cpbt02  (  character  UPLO, 
integer  N,  
integer  KD,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  RWORK,  
real  RESID  
) 
CPBT02
CPBT02 computes the residual for a solution of a Hermitian banded system of equations A*x = b: RESID = norm( B  A*X ) / ( norm(A) * norm(X) * EPS) where EPS is the machine precision.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  KD  KD is INTEGER The number of superdiagonals of the matrix A if UPLO = 'U', or the number of subdiagonals if UPLO = 'L'. KD >= 0. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides. NRHS >= 0. 
[in]  A  A is COMPLEX 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 CPBTRF 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 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 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 REAL array, dimension (N) 
[out]  RESID  RESID is REAL The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 136 of file cpbt02.f.
subroutine cpbt05  (  character  UPLO, 
integer  N,  
integer  KD,  
integer  NRHS,  
complex, dimension( ldab, * )  AB,  
integer  LDAB,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
CPBT05
CPBT05 tests the error bounds from iterative refinement for the computed solution to a system of equations A*X = B, where A is a Hermitian band matrix. RESLTS(1) = test of the error bound = norm(X  XACT) / ( norm(X) * FERR ) A large value is returned if this ratio is not less than one. RESLTS(2) = residual from the iterative refinement routine = the maximum of BERR / ( NZ*EPS + (*) ), where (*) = NZ*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i ) and NZ = max. number of nonzeros in any row of A, plus 1
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored. = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0. 
[in]  KD  KD is INTEGER The number of superdiagonals of the matrix A if UPLO = 'U', or the number of subdiagonals if UPLO = 'L'. KD >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0. 
[in]  AB  AB is COMPLEX array, dimension (LDAB,N) The upper or lower triangle of the Hermitian band matrix A, stored in the first KD+1 rows of the array. The jth column of A is stored in the jth column of the array AB as follows: if UPLO = 'U', AB(kd+1+ij,j) = A(i,j) for max(1,jkd)<=i<=j; if UPLO = 'L', AB(1+ij,j) = A(i,j) for j<=i<=min(n,j+kd). 
[in]  LDAB  LDAB is INTEGER The leading dimension of the array AB. LDAB >= KD+1. 
[in]  B  B is COMPLEX 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 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 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 REAL 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 REAL 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 REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 171 of file cpbt05.f.
subroutine cpot01  (  character  UPLO, 
integer  N,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
real, dimension( * )  RWORK,  
real  RESID  
) 
CPOT01
CPOT01 reconstructs a Hermitian positive definite matrix A from its L*L' or U'*U factorization and computes the residual norm( L*L'  A ) / ( N * norm(A) * EPS ) or norm( U'*U  A ) / ( N * norm(A) * EPS ), where EPS is the machine epsilon, L' is the conjugate transpose of L, and U' is the conjugate transpose of U.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX 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 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 REAL array, dimension (N) 
[out]  RESID  RESID is REAL If UPLO = 'L', norm(L*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U  A) / ( N * norm(A) * EPS ) 
Definition at line 107 of file cpot01.f.
subroutine cpot02  (  character  UPLO, 
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  RWORK,  
real  RESID  
) 
CPOT02
CPOT02 computes the residual for the solution of a Hermitian system of linear equations A*x = b: RESID = norm(B  A*X) / ( norm(A) * norm(X) * EPS ), where EPS is the machine epsilon.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is COMPLEX 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 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 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 REAL array, dimension (N) 
[out]  RESID  RESID is REAL The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 127 of file cpot02.f.
subroutine cpot03  (  character  UPLO, 
integer  N,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldainv, * )  AINV,  
integer  LDAINV,  
complex, dimension( ldwork, * )  WORK,  
integer  LDWORK,  
real, dimension( * )  RWORK,  
real  RCOND,  
real  RESID  
) 
CPOT03
CPOT03 computes the residual for a Hermitian matrix times its inverse: norm( I  A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ), where EPS is the machine epsilon.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX 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 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 array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RCOND  RCOND is REAL The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV). 
[out]  RESID  RESID is REAL norm(I  A*AINV) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 126 of file cpot03.f.
subroutine cpot05  (  character  UPLO, 
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
CPOT05
CPOT05 tests the error bounds from iterative refinement for the computed solution to a system of equations A*X = B, where A is a Hermitian n by n matrix. RESLTS(1) = test of the error bound = norm(X  XACT) / ( norm(X) * FERR ) A large value is returned if this ratio is not less than one. RESLTS(2) = residual from the iterative refinement routine = the maximum of BERR / ( (n+1)*EPS + (*) ), where (*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored. = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0. 
[in]  A  A is COMPLEX 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 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 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 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 REAL 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 REAL 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 REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( (n+1)*EPS + (*) ) 
Definition at line 165 of file cpot05.f.
subroutine cppt01  (  character  UPLO, 
integer  N,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
real, dimension( * )  RWORK,  
real  RESID  
) 
CPPT01
CPPT01 reconstructs a Hermitian positive definite packed matrix A from its L*L' or U'*U factorization and computes the residual norm( L*L'  A ) / ( N * norm(A) * EPS ) or norm( U'*U  A ) / ( N * norm(A) * EPS ), where EPS is the machine epsilon, L' is the conjugate transpose of L, and U' is the conjugate transpose of U.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX array, dimension (N*(N+1)/2) The original Hermitian matrix A, stored as a packed triangular matrix. 
[in,out]  AFAC  AFAC is COMPLEX 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 REAL array, dimension (N) 
[out]  RESID  RESID is REAL If UPLO = 'L', norm(L*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U  A) / ( N * norm(A) * EPS ) 
Definition at line 96 of file cppt01.f.
subroutine cppt02  (  character  UPLO, 
integer  N,  
integer  NRHS,  
complex, dimension( * )  A,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  RWORK,  
real  RESID  
) 
CPPT02
CPPT02 computes the residual in the solution of a Hermitian system of linear equations A*x = b when packed storage is used for the coefficient matrix. The ratio computed is RESID = norm(B  A*X) / ( norm(A) * norm(X) * EPS), where EPS is the machine precision.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is COMPLEX array, dimension (N*(N+1)/2) The original Hermitian matrix A, stored as a packed triangular matrix. 
[in]  X  X is COMPLEX 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 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 REAL array, dimension (N) 
[out]  RESID  RESID is REAL The maximum over the number of right hand sides of norm(B  A*X) / ( norm(A) * norm(X) * EPS ). 
Definition at line 123 of file cppt02.f.
subroutine cppt03  (  character  UPLO, 
integer  N,  
complex, dimension( * )  A,  
complex, dimension( * )  AINV,  
complex, dimension( ldwork, * )  WORK,  
integer  LDWORK,  
real, dimension( * )  RWORK,  
real  RCOND,  
real  RESID  
) 
CPPT03
CPPT03 computes the residual for a Hermitian packed matrix times its inverse: norm( I  A*AINV ) / ( N * norm(A) * norm(AINV) * EPS ), where EPS is the machine epsilon.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX array, dimension (N*(N+1)/2) The original Hermitian matrix A, stored as a packed triangular matrix. 
[in]  AINV  AINV is COMPLEX array, dimension (N*(N+1)/2) The (Hermitian) inverse of the matrix A, stored as a packed triangular matrix. 
[out]  WORK  WORK is COMPLEX array, dimension (LDWORK,N) 
[in]  LDWORK  LDWORK is INTEGER The leading dimension of the array WORK. LDWORK >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RCOND  RCOND is REAL The reciprocal of the condition number of A, computed as ( 1/norm(A) ) / norm(AINV). 
[out]  RESID  RESID is REAL norm(I  A*AINV) / ( N * norm(A) * norm(AINV) * EPS ) 
Definition at line 110 of file cppt03.f.
subroutine cppt05  (  character  UPLO, 
integer  N,  
integer  NRHS,  
complex, dimension( * )  AP,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
CPPT05
CPPT05 tests the error bounds from iterative refinement for the computed solution to a system of equations A*X = B, where A is a Hermitian matrix in packed storage format. RESLTS(1) = test of the error bound = norm(X  XACT) / ( norm(X) * FERR ) A large value is returned if this ratio is not less than one. RESLTS(2) = residual from the iterative refinement routine = the maximum of BERR / ( (n+1)*EPS + (*) ), where (*) = (n+1)*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i )
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored. = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0. 
[in]  AP  AP is COMPLEX array, dimension (N*(N+1)/2) The upper or lower triangle of the Hermitian matrix A, packed columnwise in a linear array. The jth column of A is stored in the array AP as follows: if UPLO = 'U', AP(i + (j1)*j/2) = A(i,j) for 1<=i<=j; if UPLO = 'L', AP(i + (j1)*(2nj)/2) = A(i,j) for j<=i<=n. 
[in]  B  B is COMPLEX 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 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 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 REAL 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 REAL 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 REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( (n+1)*EPS + (*) ) 
Definition at line 157 of file cppt05.f.
subroutine cpst01  (  character  UPLO, 
integer  N,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldafac, * )  AFAC,  
integer  LDAFAC,  
complex, dimension( ldperm, * )  PERM,  
integer  LDPERM,  
integer, dimension( * )  PIV,  
real, dimension( * )  RWORK,  
real  RESID,  
integer  RANK  
) 
CPST01
CPST01 reconstructs an Hermitian positive semidefinite matrix A from its L or U factors and the permutation matrix P and computes the residual norm( P*L*L'*P'  A ) / ( N * norm(A) * EPS ) or norm( P*U'*U*P'  A ) / ( N * norm(A) * EPS ), where EPS is the machine epsilon, L' is the conjugate transpose of L, and U' is the conjugate transpose of U.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the upper or lower triangular part of the Hermitian matrix A is stored: = 'U': Upper triangular = 'L': Lower triangular 
[in]  N  N is INTEGER The number of rows and columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX 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 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 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 REAL array, dimension (N) 
[out]  RESID  RESID is REAL If UPLO = 'L', norm(L*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U'*U  A) / ( N * norm(A) * EPS ) 
[in]  RANK  RANK is INTEGER number of nonzero singular values of A. 
Definition at line 136 of file cpst01.f.
subroutine cptt01  (  integer  N, 
real, dimension( * )  D,  
complex, dimension( * )  E,  
real, dimension( * )  DF,  
complex, dimension( * )  EF,  
complex, dimension( * )  WORK,  
real  RESID  
) 
CPTT01
CPTT01 reconstructs a tridiagonal matrix A from its L*D*L' factorization and computes the residual norm(L*D*L'  A) / ( n * norm(A) * EPS ), where EPS is the machine epsilon.
[in]  N  N is INTEGTER The order of the matrix A. 
[in]  D  D is REAL array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is COMPLEX array, dimension (N1) The (n1) subdiagonal elements of the tridiagonal matrix A. 
[in]  DF  DF is REAL array, dimension (N) The n diagonal elements of the factor L from the L*D*L' factorization of A. 
[in]  EF  EF is COMPLEX array, dimension (N1) The (n1) subdiagonal elements of the factor L from the L*D*L' factorization of A. 
[out]  WORK  WORK is COMPLEX array, dimension (2*N) 
[out]  RESID  RESID is REAL norm(L*D*L'  A) / (n * norm(A) * EPS) 
Definition at line 93 of file cptt01.f.
subroutine cptt02  (  character  UPLO, 
integer  N,  
integer  NRHS,  
real, dimension( * )  D,  
complex, dimension( * )  E,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
real  RESID  
) 
CPTT02
CPTT02 computes the residual for the solution to a symmetric tridiagonal system of equations: RESID = norm(B  A*X) / (norm(A) * norm(X) * EPS), where EPS is the machine epsilon.
[in]  UPLO  UPLO is CHARACTER*1 Specifies whether the superdiagonal or the subdiagonal of the tridiagonal matrix A is stored. = 'U': E is the superdiagonal of A = 'L': E is the subdiagonal of A 
[in]  N  N is INTEGTER The order of the matrix A. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of columns of the matrices B and X. NRHS >= 0. 
[in]  D  D is REAL array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is COMPLEX array, dimension (N1) The (n1) subdiagonal elements of the tridiagonal matrix A. 
[in]  X  X is COMPLEX 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 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 REAL norm(B  A*X) / (norm(A) * norm(X) * EPS) 
Definition at line 116 of file cptt02.f.
subroutine cptt05  (  integer  N, 
integer  NRHS,  
real, dimension( * )  D,  
complex, dimension( * )  E,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldxact, * )  XACT,  
integer  LDXACT,  
real, dimension( * )  FERR,  
real, dimension( * )  BERR,  
real, dimension( * )  RESLTS  
) 
CPTT05
CPTT05 tests the error bounds from iterative refinement for the computed solution to a system of equations A*X = B, where A is a Hermitian tridiagonal matrix of order n. RESLTS(1) = test of the error bound = norm(X  XACT) / ( norm(X) * FERR ) A large value is returned if this ratio is not less than one. RESLTS(2) = residual from the iterative refinement routine = the maximum of BERR / ( NZ*EPS + (*) ), where (*) = NZ*UNFL / (min_i (abs(A)*abs(X) +abs(b))_i ) and NZ = max. number of nonzeros in any row of A, plus 1
[in]  N  N is INTEGER The number of rows of the matrices X, B, and XACT, and the order of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X, B, and XACT. NRHS >= 0. 
[in]  D  D is REAL array, dimension (N) The n diagonal elements of the tridiagonal matrix A. 
[in]  E  E is COMPLEX array, dimension (N1) The (n1) subdiagonal elements of the tridiagonal matrix A. 
[in]  B  B is COMPLEX 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 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 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 REAL 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 REAL 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 REAL array, dimension (2) The maximum over the NRHS solution vectors of the ratios: RESLTS(1) = norm(X  XACT) / ( norm(X) * FERR ) RESLTS(2) = BERR / ( NZ*EPS + (*) ) 
Definition at line 150 of file cptt05.f.
subroutine cqlt01  (  integer  M, 
integer  N,  
complex, dimension( lda, * )  A,  
complex, dimension( lda, * )  AF,  
complex, dimension( lda, * )  Q,  
complex, dimension( lda, * )  L,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
CQLT01
CQLT01 tests CGEQLF, which computes the QL factorization of an mbyn matrix A, and partially tests CUNGQL which forms the mbym orthogonal matrix Q. CQLT01 compares L with Q'*A, and checks that Q is orthogonal.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is COMPLEX array, dimension (LDA,N) Details of the QL factorization of A, as returned by CGEQLF. See CGEQLF for further details. 
[out]  Q  Q is COMPLEX array, dimension (LDA,M) The mbym orthogonal matrix Q. 
[out]  L  L is COMPLEX 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 array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by CGEQLF. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( L  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 126 of file cqlt01.f.
subroutine cqlt02  (  integer  M, 
integer  N,  
integer  K,  
complex, dimension( lda, * )  A,  
complex, dimension( lda, * )  AF,  
complex, dimension( lda, * )  Q,  
complex, dimension( lda, * )  L,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
CQLT02
CQLT02 tests CUNGQL, which generates an mbyn matrix Q with orthonornmal columns that is defined as the product of k elementary reflectors. Given the QL factorization of an mbyn matrix A, CQLT02 generates the orthogonal matrix Q defined by the factorization of the last k columns of A; it compares L(mn+1:m,nk+1:n) with Q(1:m,mn+1:m)'*A(1:m,nk+1:n), and checks that the columns of Q are orthonormal.
[in]  M  M is INTEGER The number of rows of the matrix Q to be generated. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix Q to be generated. M >= N >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in]  A  A is COMPLEX array, dimension (LDA,N) The mbyn matrix A which was factorized by CQLT01. 
[in]  AF  AF is COMPLEX array, dimension (LDA,N) Details of the QL factorization of A, as returned by CGEQLF. See CGEQLF for further details. 
[out]  Q  Q is COMPLEX array, dimension (LDA,N) 
[out]  L  L is COMPLEX 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 array, dimension (N) The scalar factors of the elementary reflectors corresponding to the QL factorization in AF. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( L  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 136 of file cqlt02.f.
subroutine cqlt03  (  integer  M, 
integer  N,  
integer  K,  
complex, dimension( lda, * )  AF,  
complex, dimension( lda, * )  C,  
complex, dimension( lda, * )  CC,  
complex, dimension( lda, * )  Q,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
CQLT03
CQLT03 tests CUNMQL, which computes Q*C, Q'*C, C*Q or C*Q'. CQLT03 compares the results of a call to CUNMQL with the results of forming Q explicitly by a call to CUNGQL and then performing matrix multiplication by a call to CGEMM.
[in]  M  M is INTEGER The order of the orthogonal matrix Q. M >= 0. 
[in]  N  N is INTEGER The number of rows or columns of the matrix C; C is mbyn if Q is applied from the left, or nbym if Q is applied from the right. N >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the orthogonal matrix Q. M >= K >= 0. 
[in]  AF  AF is COMPLEX array, dimension (LDA,N) Details of the QL factorization of an mbyn matrix, as returned by CGEQLF. See CGEQLF for further details. 
[out]  C  C is COMPLEX array, dimension (LDA,N) 
[out]  CC  CC is COMPLEX array, dimension (LDA,N) 
[out]  Q  Q is COMPLEX 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 array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the QL factorization in AF. 
[out]  WORK  WORK is COMPLEX 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 REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an mbym orthogonal matrix Q. RESULT(1) = norm( Q*C  Q*C ) / ( M * norm(C) * EPS ) RESULT(2) = norm( C*Q  C*Q ) / ( M * norm(C) * EPS ) RESULT(3) = norm( Q'*C  Q'*C )/ ( M * norm(C) * EPS ) RESULT(4) = norm( C*Q'  C*Q' )/ ( M * norm(C) * EPS ) 
Definition at line 136 of file cqlt03.f.
REAL function cqpt01  (  integer  M, 
integer  N,  
integer  K,  
complex, dimension( lda, * )  A,  
complex, dimension( lda, * )  AF,  
integer  LDA,  
complex, dimension( * )  TAU,  
integer, dimension( * )  JPVT,  
complex, dimension( lwork )  WORK,  
integer  LWORK  
) 
CQPT01
CQPT01 tests the QRfactorization with pivoting of a matrix A. The array AF contains the (possibly partial) QRfactorization of A, where the upper triangle of AF(1:k,1:k) is a partial triangular factor, the entries below the diagonal in the first k columns are the Householder vectors, and the rest of AF contains a partially updated matrix. This function returns A*P  Q*R/(norm(A)*eps*M)
[in]  M  M is INTEGER The number of rows of the matrices A and AF. 
[in]  N  N is INTEGER The number of columns of the matrices A and AF. 
[in]  K  K is INTEGER The number of columns of AF that have been reduced to upper triangular form. 
[in]  A  A is COMPLEX array, dimension (LDA, N) The original matrix A. 
[in]  AF  AF is COMPLEX array, dimension (LDA,N) The (possibly partial) output of CGEQPF. 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 array, dimension (K) Details of the Householder transformations as returned by CGEQPF. 
[in]  JPVT  JPVT is INTEGER array, dimension (N) Pivot information as returned by CGEQPF. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= M*N+N. 
Definition at line 120 of file cqpt01.f.
subroutine cqrt01  (  integer  M, 
integer  N,  
complex, dimension( lda, * )  A,  
complex, dimension( lda, * )  AF,  
complex, dimension( lda, * )  Q,  
complex, dimension( lda, * )  R,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
CQRT01
CQRT01 tests CGEQRF, which computes the QR factorization of an mbyn matrix A, and partially tests CUNGQR which forms the mbym orthogonal matrix Q. CQRT01 compares R with Q'*A, and checks that Q is orthogonal.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is COMPLEX array, dimension (LDA,N) Details of the QR factorization of A, as returned by CGEQRF. See CGEQRF for further details. 
[out]  Q  Q is COMPLEX array, dimension (LDA,M) The mbym orthogonal matrix Q. 
[out]  R  R is COMPLEX 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 array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by CGEQRF. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( R  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 126 of file cqrt01.f.
subroutine cqrt01p  (  integer  M, 
integer  N,  
complex, dimension( lda, * )  A,  
complex, dimension( lda, * )  AF,  
complex, dimension( lda, * )  Q,  
complex, dimension( lda, * )  R,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
CQRT01P
CQRT01P tests CGEQRFP, which computes the QR factorization of an mbyn matrix A, and partially tests CUNGQR which forms the mbym orthogonal matrix Q. CQRT01P compares R with Q'*A, and checks that Q is orthogonal.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is COMPLEX array, dimension (LDA,N) Details of the QR factorization of A, as returned by CGEQRFP. See CGEQRFP for further details. 
[out]  Q  Q is COMPLEX array, dimension (LDA,M) The mbym orthogonal matrix Q. 
[out]  R  R is COMPLEX 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 array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by CGEQRFP. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( R  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 126 of file cqrt01p.f.
subroutine cqrt02  (  integer  M, 
integer  N,  
integer  K,  
complex, dimension( lda, * )  A,  
complex, dimension( lda, * )  AF,  
complex, dimension( lda, * )  Q,  
complex, dimension( lda, * )  R,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
CQRT02
CQRT02 tests CUNGQR, which generates an mbyn matrix Q with orthonornmal columns that is defined as the product of k elementary reflectors. Given the QR factorization of an mbyn matrix A, CQRT02 generates the orthogonal matrix Q defined by the factorization of the first k columns of A; it compares R(1:n,1:k) with Q(1:m,1:n)'*A(1:m,1:k), and checks that the columns of Q are orthonormal.
[in]  M  M is INTEGER The number of rows of the matrix Q to be generated. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix Q to be generated. M >= N >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the matrix Q. N >= K >= 0. 
[in]  A  A is COMPLEX array, dimension (LDA,N) The mbyn matrix A which was factorized by CQRT01. 
[in]  AF  AF is COMPLEX array, dimension (LDA,N) Details of the QR factorization of A, as returned by CGEQRF. See CGEQRF for further details. 
[out]  Q  Q is COMPLEX array, dimension (LDA,N) 
[out]  R  R is COMPLEX 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 array, dimension (N) The scalar factors of the elementary reflectors corresponding to the QR factorization in AF. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( R  Q'*A ) / ( M * norm(A) * EPS ) RESULT(2) = norm( I  Q'*Q ) / ( M * EPS ) 
Definition at line 135 of file cqrt02.f.
subroutine cqrt03  (  integer  M, 
integer  N,  
integer  K,  
complex, dimension( lda, * )  AF,  
complex, dimension( lda, * )  C,  
complex, dimension( lda, * )  CC,  
complex, dimension( lda, * )  Q,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
CQRT03
CQRT03 tests CUNMQR, which computes Q*C, Q'*C, C*Q or C*Q'. CQRT03 compares the results of a call to CUNMQR with the results of forming Q explicitly by a call to CUNGQR and then performing matrix multiplication by a call to CGEMM.
[in]  M  M is INTEGER The order of the orthogonal matrix Q. M >= 0. 
[in]  N  N is INTEGER The number of rows or columns of the matrix C; C is mbyn if Q is applied from the left, or nbym if Q is applied from the right. N >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the orthogonal matrix Q. M >= K >= 0. 
[in]  AF  AF is COMPLEX array, dimension (LDA,N) Details of the QR factorization of an mbyn matrix, as returnedby CGEQRF. See CGEQRF for further details. 
[out]  C  C is COMPLEX array, dimension (LDA,N) 
[out]  CC  CC is COMPLEX array, dimension (LDA,N) 
[out]  Q  Q is COMPLEX 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 array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the QR factorization in AF. 
[out]  WORK  WORK is COMPLEX 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 REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an mbym orthogonal matrix Q. RESULT(1) = norm( Q*C  Q*C ) / ( M * norm(C) * EPS ) RESULT(2) = norm( C*Q  C*Q ) / ( M * norm(C) * EPS ) RESULT(3) = norm( Q'*C  Q'*C )/ ( M * norm(C) * EPS ) RESULT(4) = norm( C*Q'  C*Q' )/ ( M * norm(C) * EPS ) 
Definition at line 136 of file cqrt03.f.
subroutine cqrt04  (  integer  M, 
integer  N,  
integer  NB,  
real, dimension(6)  RESULT  
) 
CQRT04
CQRT04 tests CGEQRT and CGEMQRT.
[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 REAL array, dimension (6) Results of each of the six tests below. RESULT(1) =  A  Q R  RESULT(2) =  I  Q^H Q  RESULT(3) =  Q C  Q C  RESULT(4) =  Q^H C  Q^H C  RESULT(5) =  C Q  C Q  RESULT(6) =  C Q^H  C Q^H  
Definition at line 74 of file cqrt04.f.
subroutine cqrt05  (  integer  M, 
integer  N,  
integer  L,  
integer  NB,  
real, dimension(6)  RESULT  
) 
CQRT05
CQRT05 tests CTPQRT and CTPMQRT.
[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 REAL array, dimension (6) Results of each of the six tests below. RESULT(1) =  A  Q R  RESULT(2) =  I  Q^H Q  RESULT(3) =  Q C  Q C  RESULT(4) =  Q^H C  Q^H C  RESULT(5) =  C Q  C Q  RESULT(6) =  C Q^H  C Q^H  
Definition at line 81 of file cqrt05.f.
REAL function cqrt11  (  integer  M, 
integer  K,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK  
) 
CQRT11
CQRT11 computes the test ratio  Q'*Q  I  / (eps * m) where the orthogonal matrix Q is represented as a product of elementary transformations. Each transformation has the form H(k) = I  tau(k) v(k) v(k)' where tau(k) is stored in TAU(k) and v(k) is an mvector of the form [ 0 ... 0 1 x(k) ]', where x(k) is a vector of length mk stored in A(k+1:m,k).
[in]  M  M is INTEGER The number of rows of the matrix A. 
[in]  K  K is INTEGER The number of columns of A whose subdiagonal entries contain information about orthogonal transformations. 
[in]  A  A is COMPLEX 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 array, dimension (K) The scaling factors tau for the elementary transformations as computed by the QR factorization routine. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= M*M + M. 
Definition at line 99 of file cqrt11.f.
REAL function cqrt12  (  integer  M, 
integer  N,  
complex, dimension( lda, * )  A,  
integer  LDA,  
real, dimension( * )  S,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK  
) 
CQRT12
CQRT12 computes the singular values `svlues' of the upper trapezoid of A(1:M,1:N) and returns the ratio  s  svlues/(svlues*eps*max(M,N))
[in]  M  M is INTEGER The number of rows of the matrix A. 
[in]  N  N is INTEGER The number of columns of the matrix A. 
[in]  A  A is COMPLEX array, dimension (LDA,N) The MbyN matrix A. Only the upper trapezoid is referenced. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[in]  S  S is REAL array, dimension (min(M,N)) The singular values of the matrix A. 
[out]  WORK  WORK is COMPLEX 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 REAL array, dimension (4*min(M,N)) 
Definition at line 97 of file cqrt12.f.
subroutine cqrt13  (  integer  SCALE, 
integer  M,  
integer  N,  
complex, dimension( lda, * )  A,  
integer  LDA,  
real  NORMA,  
integer, dimension( 4 )  ISEED  
) 
CQRT13
CQRT13 generates a fullrank matrix that may be scaled to have large or small norm.
[in]  SCALE  SCALE is INTEGER SCALE = 1: normally scaled matrix SCALE = 2: matrix scaled up SCALE = 3: matrix scaled down 
[in]  M  M is INTEGER The number of rows of the matrix A. 
[in]  N  N is INTEGER The number of columns of A. 
[out]  A  A is COMPLEX array, dimension (LDA,N) The MbyN matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[out]  NORMA  NORMA is REAL The onenorm of A. 
[in,out]  ISEED  ISEED is integer array, dimension (4) Seed for random number generator 
Definition at line 92 of file cqrt13.f.
REAL function cqrt14  (  character  TRANS, 
integer  M,  
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( lwork )  WORK,  
integer  LWORK  
) 
CQRT14
CQRT14 checks whether X is in the row space of A or A'. It does so by scaling both X and A such that their norms are in the range [sqrt(eps), 1/sqrt(eps)], then computing a QR factorization of [A,X] (if TRANS = 'C') or an LQ factorization of [A',X]' (if TRANS = 'N'), and returning the norm of the trailing triangle, scaled by MAX(M,N,NRHS)*eps.
[in]  TRANS  TRANS is CHARACTER*1 = 'N': No transpose, check for X in the row space of A = 'C': Conjugate transpose, check for X in row space of A'. 
[in]  M  M is INTEGER The number of rows of the matrix A. 
[in]  N  N is INTEGER The number of columns of the matrix A. 
[in]  NRHS  NRHS is INTEGER The number of right hand sides, i.e., the number of columns of X. 
[in]  A  A is COMPLEX array, dimension (LDA,N) The MbyN matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[in]  X  X is COMPLEX array, dimension (LDX,NRHS) If TRANS = 'N', the NbyNRHS matrix X. IF TRANS = 'C', the MbyNRHS matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. 
[out]  WORK  WORK is COMPLEX array dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER length of workspace array required If TRANS = 'N', LWORK >= (M+NRHS)*(N+2); if TRANS = 'C', LWORK >= (N+NRHS)*(M+2). 
Definition at line 116 of file cqrt14.f.
subroutine cqrt15  (  integer  SCALE, 
integer  RKSEL,  
integer  M,  
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  S,  
integer  RANK,  
real  NORMA,  
real  NORMB,  
integer, dimension( 4 )  ISEED,  
complex, dimension( lwork )  WORK,  
integer  LWORK  
) 
CQRT15
CQRT15 generates a matrix with full or deficient rank and of various norms.
[in]  SCALE  SCALE is INTEGER SCALE = 1: normally scaled matrix SCALE = 2: matrix scaled up SCALE = 3: matrix scaled down 
[in]  RKSEL  RKSEL is INTEGER RKSEL = 1: full rank matrix RKSEL = 2: rankdeficient matrix 
[in]  M  M is INTEGER The number of rows of the matrix A. 
[in]  N  N is INTEGER The number of columns of A. 
[in]  NRHS  NRHS is INTEGER The number of columns of B. 
[out]  A  A is COMPLEX array, dimension (LDA,N) The MbyN matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. 
[out]  B  B is COMPLEX 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 REAL 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 REAL onenorm norm of A. 
[out]  NORMB  NORMB is REAL onenorm norm of B. 
[in,out]  ISEED  ISEED is integer array, dimension (4) seed for random number generator. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER length of work space required. LWORK >= MAX(M+MIN(M,N),NRHS*MIN(M,N),2*N+M) 
Definition at line 149 of file cqrt15.f.
subroutine cqrt16  (  character  TRANS, 
integer  M,  
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
real, dimension( * )  RWORK,  
real  RESID  
) 
CQRT16
CQRT16 computes the residual for a solution of a system of linear equations A*x = b or A'*x = b: RESID = norm(B  A*X) / ( max(m,n) * norm(A) * norm(X) * EPS ), where EPS is the machine epsilon.
[in]  TRANS  TRANS is CHARACTER*1 Specifies the form of the system of equations: = 'N': A *x = b = 'T': A^T*x = b, where A^T is the transpose of A = 'C': A^H*x = b, where A^H is the conjugate transpose of A 
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  NRHS  NRHS is INTEGER The number of columns of B, the matrix of right hand sides. NRHS >= 0. 
[in]  A  A is COMPLEX 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 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 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 REAL array, dimension (M) 
[out]  RESID  RESID is REAL The maximum over the number of right hand sides of norm(B  A*X) / ( max(m,n) * norm(A) * norm(X) * EPS ). 
Definition at line 133 of file cqrt16.f.
REAL function cqrt17  (  character  TRANS, 
integer  IRESID,  
integer  M,  
integer  N,  
integer  NRHS,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( ldx, * )  X,  
integer  LDX,  
complex, dimension( ldb, * )  B,  
integer  LDB,  
complex, dimension( ldb, * )  C,  
complex, dimension( lwork )  WORK,  
integer  LWORK  
) 
CQRT17
CQRT17 computes the ratio  R'*op(A) /(A*alpha*max(M,N,NRHS)*eps) where R = op(A)*X  B, op(A) is A or A', and alpha = B if IRESID = 1 (zeroresidual problem) alpha = R if IRESID = 2 (otherwise).
[in]  TRANS  TRANS is CHARACTER*1 Specifies whether or not the transpose of A is used. = 'N': No transpose, op(A) = A. = 'C': Conjugate transpose, op(A) = A'. 
[in]  IRESID  IRESID is INTEGER IRESID = 1 indicates zeroresidual problem. IRESID = 2 indicates nonzero residual. 
[in]  M  M is INTEGER The number of rows of the matrix A. If TRANS = 'N', the number of rows of the matrix B. If TRANS = 'C', the number of rows of the matrix X. 
[in]  N  N is INTEGER The number of columns of the matrix A. If TRANS = 'N', the number of rows of the matrix X. If TRANS = 'C', the number of rows of the matrix B. 
[in]  NRHS  NRHS is INTEGER The number of columns of the matrices X and B. 
[in]  A  A is COMPLEX array, dimension (LDA,N) The mbyn matrix A. 
[in]  LDA  LDA is INTEGER The leading dimension of the array A. LDA >= M. 
[in]  X  X is COMPLEX array, dimension (LDX,NRHS) If TRANS = 'N', the nbynrhs matrix X. If TRANS = 'C', the mbynrhs matrix X. 
[in]  LDX  LDX is INTEGER The leading dimension of the array X. If TRANS = 'N', LDX >= N. If TRANS = 'C', LDX >= M. 
[in]  B  B is COMPLEX array, dimension (LDB,NRHS) If TRANS = 'N', the mbynrhs matrix B. If TRANS = 'C', the nbynrhs matrix B. 
[in]  LDB  LDB is INTEGER The leading dimension of the array B. If TRANS = 'N', LDB >= M. If TRANS = 'C', LDB >= N. 
[out]  C  C is COMPLEX array, dimension (LDB,NRHS) 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= NRHS*(M+N). 
Definition at line 150 of file cqrt17.f.
subroutine crqt01  (  integer  M, 
integer  N,  
complex, dimension( lda, * )  A,  
complex, dimension( lda, * )  AF,  
complex, dimension( lda, * )  Q,  
complex, dimension( lda, * )  R,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
CRQT01
CRQT01 tests CGERQF, which computes the RQ factorization of an mbyn matrix A, and partially tests CUNGRQ which forms the nbyn orthogonal matrix Q. CRQT01 compares R with A*Q', and checks that Q is orthogonal.
[in]  M  M is INTEGER The number of rows of the matrix A. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix A. N >= 0. 
[in]  A  A is COMPLEX array, dimension (LDA,N) The mbyn matrix A. 
[out]  AF  AF is COMPLEX array, dimension (LDA,N) Details of the RQ factorization of A, as returned by CGERQF. See CGERQF for further details. 
[out]  Q  Q is COMPLEX array, dimension (LDA,N) The nbyn orthogonal matrix Q. 
[out]  R  R is COMPLEX 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 array, dimension (min(M,N)) The scalar factors of the elementary reflectors, as returned by CGERQF. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (max(M,N)) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( R  A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I  Q*Q' ) / ( N * EPS ) 
Definition at line 126 of file crqt01.f.
subroutine crqt02  (  integer  M, 
integer  N,  
integer  K,  
complex, dimension( lda, * )  A,  
complex, dimension( lda, * )  AF,  
complex, dimension( lda, * )  Q,  
complex, dimension( lda, * )  R,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
CRQT02
CRQT02 tests CUNGRQ, which generates an mbyn matrix Q with orthonornmal rows that is defined as the product of k elementary reflectors. Given the RQ factorization of an mbyn matrix A, CRQT02 generates the orthogonal matrix Q defined by the factorization of the last k rows of A; it compares R(mk+1:m,nm+1:n) with A(mk+1:m,1:n)*Q(nm+1:n,1:n)', and checks that the rows of Q are orthonormal.
[in]  M  M is INTEGER The number of rows of the matrix Q to be generated. M >= 0. 
[in]  N  N is INTEGER The number of columns of the matrix Q to be generated. N >= M >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the matrix Q. M >= K >= 0. 
[in]  A  A is COMPLEX array, dimension (LDA,N) The mbyn matrix A which was factorized by CRQT01. 
[in]  AF  AF is COMPLEX array, dimension (LDA,N) Details of the RQ factorization of A, as returned by CGERQF. See CGERQF for further details. 
[out]  Q  Q is COMPLEX array, dimension (LDA,N) 
[out]  R  R is COMPLEX 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 array, dimension (M) The scalar factors of the elementary reflectors corresponding to the RQ factorization in AF. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The dimension of the array WORK. 
[out]  RWORK  RWORK is REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (2) The test ratios: RESULT(1) = norm( R  A*Q' ) / ( N * norm(A) * EPS ) RESULT(2) = norm( I  Q*Q' ) / ( N * EPS ) 
Definition at line 136 of file crqt02.f.
subroutine crqt03  (  integer  M, 
integer  N,  
integer  K,  
complex, dimension( lda, * )  AF,  
complex, dimension( lda, * )  C,  
complex, dimension( lda, * )  CC,  
complex, dimension( lda, * )  Q,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK,  
real, dimension( * )  RWORK,  
real, dimension( * )  RESULT  
) 
CRQT03
CRQT03 tests CUNMRQ, which computes Q*C, Q'*C, C*Q or C*Q'. CRQT03 compares the results of a call to CUNMRQ with the results of forming Q explicitly by a call to CUNGRQ and then performing matrix multiplication by a call to CGEMM.
[in]  M  M is INTEGER The number of rows or columns of the matrix C; C is nbym if Q is applied from the left, or mbyn if Q is applied from the right. M >= 0. 
[in]  N  N is INTEGER The order of the orthogonal matrix Q. N >= 0. 
[in]  K  K is INTEGER The number of elementary reflectors whose product defines the orthogonal matrix Q. N >= K >= 0. 
[in]  AF  AF is COMPLEX array, dimension (LDA,N) Details of the RQ factorization of an mbyn matrix, as returned by CGERQF. See CGERQF for further details. 
[out]  C  C is COMPLEX array, dimension (LDA,N) 
[out]  CC  CC is COMPLEX array, dimension (LDA,N) 
[out]  Q  Q is COMPLEX 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 array, dimension (min(M,N)) The scalar factors of the elementary reflectors corresponding to the RQ factorization in AF. 
[out]  WORK  WORK is COMPLEX 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 REAL array, dimension (M) 
[out]  RESULT  RESULT is REAL array, dimension (4) The test ratios compare two techniques for multiplying a random matrix C by an nbyn orthogonal matrix Q. RESULT(1) = norm( Q*C  Q*C ) / ( N * norm(C) * EPS ) RESULT(2) = norm( C*Q  C*Q ) / ( N * norm(C) * EPS ) RESULT(3) = norm( Q'*C  Q'*C )/ ( N * norm(C) * EPS ) RESULT(4) = norm( C*Q'  C*Q' )/ ( N * norm(C) * EPS ) 
Definition at line 136 of file crqt03.f.
REAL function crzt01  (  integer  M, 
integer  N,  
complex, dimension( lda, * )  A,  
complex, dimension( lda, * )  AF,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK  
) 
CRZT01
CRZT01 returns  A  R*Q  / ( M * eps * A ) for an upper trapezoidal A that was factored with CTZRZF.
[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]  A  A is COMPLEX array, dimension (LDA,N) The original upper trapezoidal M by N matrix A. 
[in]  AF  AF is COMPLEX array, dimension (LDA,N) The output of CTZRZF for input matrix A. The lower triangle is not referenced. 
[in]  LDA  LDA is INTEGER The leading dimension of the arrays A and AF. 
[in]  TAU  TAU is COMPLEX array, dimension (M) Details of the Householder transformations as returned by CTZRZF. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER The length of the array WORK. LWORK >= m*n + m. 
Definition at line 98 of file crzt01.f.
REAL function crzt02  (  integer  M, 
integer  N,  
complex, dimension( lda, * )  AF,  
integer  LDA,  
complex, dimension( * )  TAU,  
complex, dimension( lwork )  WORK,  
integer  LWORK  
) 
CRZT02
CRZT02 returns  I  Q'*Q  / ( M * eps) where the matrix Q is defined by the Householder transformations generated by CTZRZF.
[in]  M  M is INTEGER The number of rows of the matrix AF. 
[in]  N  N is INTEGER The number of columns of the matrix AF. 
[in]  AF  AF is COMPLEX array, dimension (LDA,N) The output of CTZRZF. 
[in]  LDA  LDA is INTEGER The leading dimension of the array AF. 
[in]  TAU  TAU is COMPLEX array, dimension (M) Details of the Householder transformations as returned by CTZRZF. 
[out]  WORK  WORK is COMPLEX array, dimension (LWORK) 
[in]  LWORK  LWORK is INTEGER Length of WORK array. LWORK >= N*N+N. 
Definition at line 91 of file crzt02.f.
subroutine csbmv  (  character  UPLO, 
integer  N,  
integer  K,  
complex  ALPHA,  
complex, dimension( lda, * )  A,  
integer  LDA,  
complex, dimension( * )  X,  
integer  INCX,  
complex  BETA,  
complex, dimension( * )  Y,  
integer  INCY  
) 
CSBMV
CSBMV performs the matrixvector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric band matrix, with k superdiagonals.
UPLO  CHARACTER*1 On entry, UPLO specifies whether the upper or lower triangular part of the band matrix A is being supplied as follows: UPLO = 'U' or 'u' The upper triangular part of A is being supplied. UPLO = 'L' or 'l' The lower triangular part of A is being supplied. Unchanged on exit. N  INTEGER On entry, N specifies the order of the matrix A. N must be at least zero. Unchanged on exit. K  INTEGER On entry, K specifies the number of superdiagonals of the matrix A. K must satisfy 0 .le. K. Unchanged on exit. ALPHA  COMPLEX On entry, ALPHA specifies the scalar alpha. Unchanged on exit. A  COMPLEX array, dimension( LDA, N ) Before entry with UPLO = 'U' or 'u', the leading ( k + 1 ) by n part of the array A must contain the upper triangular band part of the symmetric matrix, supplied column by column, with the leading diagonal of the matrix in row ( k + 1 ) of the array, the first superdiagonal starting at position 2 in row k, and so on. The top left k by k triangle of the array A is not referenced. The following program segment will transfer the upper triangular part of a symmetric band matrix from conventional full matrix storage to band storage: DO 20, J = 1, N M = K + 1  J DO 10, I = MAX( 1, J  K ), J A( M + I, J ) = matrix( I, J ) 10 CONTINUE 20 CONTINUE Before entry with UPLO = 'L' or 'l', the leading ( k + 1 ) by n part of the array A must contain the lower triangular band part of the symmetric matrix, supplied column by column, with the leading diagonal of the matrix in row 1 of the array, the first subdiagonal starting at position 1 in row 2, and so on. The bottom right k by k triangle of the array A is not referenced. The following program segment will transfer the lower triangular part of a symmetric band matrix from conventional full matrix storage to band storage: DO 20, J = 1, N M = 1  J DO 10, I = J, MIN( N, J + K ) A( M + I, J ) = matrix( I, J ) 10 CONTINUE 20 CONTINUE Unchanged on exit. LDA  INTEGER On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. LDA must be at least ( k + 1 ). Unchanged on exit. X  COMPLEX array, dimension at least ( 1 + ( N  1 )*abs( INCX ) ). Before entry, the incremented array X must contain the vector x. Unchanged on exit. INCX  INTEGER On entry, INCX specifies the increment for the elements of X. INCX must not be zero. Unchanged on exit. BETA  COMPLEX On entry, BETA specifies the scalar beta. Unchanged on exit. Y  COMPLEX array, dimension at least ( 1 + ( N  1 )*abs( INCY ) ). Before entry, the incremented array Y must contain the vector y. On exit, Y is overwritten by the updated vector y. INCY  INTEGER On entry, INCY specifies the increment for the elements of Y. INCY must not be zero. Unchanged on exit.
Definition at line 152 of file csbmv.f.
subroutine cspt01  (  character  UPLO, 
integer  N,  
complex, dimension( * )  A,  
complex, dimension( * )  AFAC,  
integer, dimension( * )  IPIV,  
complex, dimension( ldc, * )  C,  
integer  LDC,  
real, dimension( * )  RWORK,  
real  RESID  
) 
CSPT01
CSPT01 reconstructs a symmetric indefinite packed matrix A from its diagonal pivoting factorization A = U*D*U' or A = L*D*L' and computes the residual norm( C  A ) / ( N * norm(A) * EPS ), where C is the reconstructed matrix and EPS is the machine epsilon.
[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 order of the matrix A. N >= 0. 
[in]  A  A is COMPLEX array, dimension (N*(N+1)/2) The original symmetric matrix A, stored as a packed triangular matrix. 
[in]  AFAC  AFAC is COMPLEX array, dimension (N*(N+1)/2) The factored form of the matrix A, stored as a packed triangular matrix. AFAC contains the block diagonal matrix D and the multipliers used to obtain the factor L or U from the L*D*L' or U*D*U' factorization as computed by CSPTRF. 
[in]  IPIV  IPIV is INTEGER array, dimension (N) The pivot indices from CSPTRF. 
[out]  C  C is COMPLEX array, dimension (LDC,N) 
[in]  LDC  LDC is INTEGER The leading dimension of the array C. LDC >= max(1,N). 
[out]  RWORK  RWORK is REAL array, dimension (N) 
[out]  RESID  RESID is REAL If UPLO = 'L', norm(L*D*L'  A) / ( N * norm(A) * EPS ) If UPLO = 'U', norm(U*D*U'  A) / ( N * norm(A) * EPS ) 
Definition at line 113 of file cspt01.f.
subroutine cspt02  (  character  UPLO, 
integer  N,  
integer  NRHS 